danisss9.Lite 0.0.16

Lite

Lite is an experimental HTML, CSS, and JavaScript rendering engine for Windows, written in C#. It turns a URL into a native Win32 window without embedding WebView2 or another browser engine.

HTML and CSS are parsed with AngleSharp, layout is calculated by Lite's own layout engine, pixels are drawn with SkiaSharp, and JavaScript runs in Jint. The project is intended for developers exploring browser internals, building constrained HTML-driven interfaces, or experimenting with a small managed rendering stack.

Lite implements a practical subset of the web platform. It is not a replacement for a production browser, and arbitrary websites should not be expected to render exactly as they do in Chromium, Firefox, or Safari.

Highlights

• Native Windows host and message loop with mouse, keyboard, scrolling, navigation, and page transitions
• Custom block, inline, flex, table, float, absolute, and fixed-position layout
• CSS cascade, selectors, media queries, custom properties, generated content, transforms, transitions, and keyframe animations
• DOM APIs, events, timers, promises, fetch, XMLHttpRequest, Web Storage, history, and ES modules
• Forms and common controls, including validation and submission
• Inline SVG, Canvas 2D, images, iframes, audio, and video
• Optional LibVLC media backend through Lite.Media
• Unit, Web Platform Test, CSS 2.1, Test262, and Acid test harnesses

Requirements

• Windows
• .NET 8 SDK to build the repository
• An HTTP or HTTPS URL to render

Lite currently uses Win32 directly, so it is not cross-platform. Local pages should be served over HTTP; the example project includes a small static-file server for that purpose.

Install

Add the package from NuGet:

dotnet add package danisss9.Lite

During repository development, reference the project directly instead:

<ItemGroup>
  <ProjectReference Include="..\Lite\Lite.csproj" />
</ItemGroup>

Create a window

using Lite;

var window = new BrowserWindow(
    url: "https://example.com",
    title: "My Lite App",
    width: 1024,
    height: 768);

window.Run();

BrowserWindow.Run() loads the document, creates the native window, and enters the Win32 message loop. It blocks the calling thread until the window closes, so call it from the application's main UI thread.

The constructor is:

BrowserWindow(
    string url,
    string title = "Lite",
    int width = 800,
    int height = 600)

Run the example

The example hosts the files in Lite.Example/resources at http://localhost:4444 and opens the gallery in Lite. Run it with Lite.Example as the working directory so its relative resources path resolves correctly:

cd Lite.Example
dotnet run

The gallery contains focused pages for typography, layout, colors and effects, lists and tables, forms, transforms and animations, SVG and Canvas, JavaScript and DOM APIs, iframes, and media.

Pass a URL to open a remote page in the example window instead of starting the gallery server:

dotnet run --project Lite.Example -- https://lite.duckduckgo.com/lite/

Real audio and video playback use LibVLC when its native Windows libraries are available. If initialization fails, the example falls back to Lite's simulated media timeline.

How it works

The main rendering path is:

URL -> resource loading -> HTML/CSS parsing -> style resolution
    -> layout tree -> box layout -> SkiaSharp painting -> Win32 window

JavaScript -> DOM mutation/event -> style and layout invalidation -> repaint

Repository layout

Development

Build the complete solution:

dotnet build Lite.sln

Run the regression suite:

dotnet run --project Lite.Tests/Lite.Tests.csproj -c Release

The upstream conformance suites are downloaded separately and pinned by Lite.Conformance/test-suites.lock.json:

./scripts/fetch-tests.ps1

dotnet run --project Lite.Conformance -c Release -- --suite profile
dotnet run --project Lite.Conformance -c Release -- --suite css21
dotnet run --project Lite.Conformance -c Release -- --suite wpt
dotnet run --project Lite.Conformance -c Release -- --suite html5
dotnet run --project Lite.Conformance -c Release -- --suite test262
dotnet run --project Lite.Conformance -c Release -- --suite acid

Lite targets the HTML 5.0 Recommendation of 28 October 2014, alongside the separate CSS 2.1 and ES2020 workstreams. The active profile publishes its exclusions and incomplete coverage. Historical HTML 5.2 contracts remain in Lite.Conformance/Profile/history/.

Curated green tests protect existing behavior; they do not establish complete standards conformance. --suite html5 runs the small set of reviewed assertions. html5ProfileReady remains false until all applicable requirements and required dependencies have current passing evidence. See HTML 5.0 implementation and evidence for the remaining work, upstream WPT serving, and report commands.

For JavaScript, see ES2020 implementation and remaining features. --suite test262 runs the complete classified corpus; --test262-set smoke selects the small regression set. python scripts/run-es2020.py runs eight Windows shards and the host checks, and reports the readiness verdict. Its exit status covers execution; es2020ProfileReady stays false until the normative and edition review is finished, and only NuGet publication enforces it.

Contributing

Bug reports and focused pull requests are welcome. For rendering fixes, include a minimal HTML/CSS/JS reproduction and add the smallest relevant regression test. Run the unit suite and the affected conformance suite before opening a pull request.

When changing rendering behavior, keep parsing, style resolution, layout, painting, hit testing, and DOM-driven invalidation in mind: a visual fix in one stage can expose a mismatch in another.

License

Lite is available under the MIT License.