Displaying real web pages
The NativeX web engine (HTML, CSS, JavaScript) is part of the library. The Mathis browser uses it to load and display real websites. Compatibility with the modern Web keeps improving, but it remains partial.
NativeX brings together a portable system layer, an XML interface engine, a web engine and media support, all written natively. No heavy runtime, no hidden browser: the application knows what it owns. It already runs a complete web browser on Windows, Linux and macOS; embedded devices are the next frontier.
The best proof of a framework is the applications it runs. NativeX currently powers a complete web browser and several demonstration tools.
The NativeX web engine (HTML, CSS, JavaScript) is part of the library. The Mathis browser uses it to load and display real websites. Compatibility with the modern Web keeps improving, but it remains partial.
Tabs, persistent profiles, private browsing, downloads, image, audio, video and PDF viewers, printing, crash reports: Mathis exercises the framework the way a real product would.
After each cycle (opening a page, closing it, playing a video, paging through a PDF), memory and graphics surfaces must return exactly to their starting point. Automated tests check this on Windows.
NativeX Setup, our installer generator, already produces the Mathis packages for Linux and macOS, as well as the internal SDK installers for Windows, Linux and macOS.
In early November the engine gained interfaces that current websites expect: DOM mutation observers, Range, form validation, focus, embedded frames, crypto.subtle for digests and HMAC. In Mathis, the DuckDuckGo results pages display; Qwant's are blocked by its anti-bot protection. Rendering can still improve.
A native diagnostic trace, off by default, records a session end to end (network, cookies, script errors, page processes) and exports it as a single document. Sensitive data is masked at recording time, and nothing is traced in private browsing.
The project is ambitious: a single native foundation to write a C/C++ application once and deliver it from the desktop all the way to industrial equipment. Here, step by step, is what is done, what comes next and what remains a goal.
Control panels, supervision and diagnostic tools with a controlled footprint.
Display help, dashboards or HTML pages without shipping Chromium.
A lightweight native application, cleanly installed on all three systems.
Bring your C/C++ code to a new target without rewriting the interface.
Schedule. No availability date is announced: each step will be published once it has been verified. Embedded targets are offered today as porting work through Moobotec services.
NativeX is organized around a system layer written in C and an interface engine written in C++. Everything that depends on the operating system goes through the C layer: porting NativeX to a new target means implementing that layer, not rewriting the application.
Portable C11 foundation: memory, files, threads, mutexes, timers, logging, HTTP/1.1 and HTTP/2, TLS, JSON, XML, HTML, CSS, JavaScript, images, audio (WAVE, MP3, FLAC, Ogg Vorbis), MP4 video and adaptation to each operating system.
Native application and interface layer: XML layouts, controls, events, 2D/3D rendering, windows for each platform and an embeddable web engine.
Every capability below exists in the code and runs in a demonstration application.
A complete web browser built on NativeX: the most demanding demonstration of the framework.
Windows, panels, layouts, controls, commands and data are described once and rendered through native platform backends.
A full demo app exercises widgets, menus, dialogs, list views, tables, text editing, docking and theme behavior.
A demonstration HTTP client: it fetches a page, parses it, applies the CSS, runs the JavaScript and displays it, without an embedded browser.
A demo server shows request handling, routing, response generation and practical UI integration for network tools.
2D and 3D command lists can run through a GL backend or a recording device for headless tests.
An XML editor with live preview, built on the same interface layer as applications.
The interface engine keeps a C++ implementation and exposes a C facade where integration code needs a stable ABI-style boundary.
Real screenshots: the Mathis browser rendering this site, then the framework demos (controls, HTTP client, graphics, server tooling and XML editor).






Note. Screenshots are generated from the current demo applications and reused by the public site assets.
The public contract is split by layer: low-level C services in
LIB_SysOs, C++ engine internals in LIB_FrameworkNext,
and a C facade for application-facing integration.
Files, memory, network, parsing, media and OS integration are handled by the C11 foundation.
The C++ framework owns widgets, rendering commands, input dispatch and higher-level application objects.
Selected entry points are exposed through C headers for integration scenarios that do not want a C++ ABI boundary.
The NativeX web engine is written inside the framework, without handing rendering over to a third-party browser. It is measured continuously against reference tests, but we do not claim a conformance score: compatibility with real websites improves page by page.
Historical local-bench snapshot, August 2026; not a current qualification.
HTML parsing, DOM tree construction, attributes, text nodes, events, selectors, forms, dataset, classList, named access and serialization are covered by tests and WPT work.
The CSS parser, cascade and style engine cover selectors, units, colors, inheritance, shorthand expansion, specificity, pseudo-elements, gradients and layout-facing resolved values. For @font-face, the foundation can already recognize, check and decompress a web font (TrueType, OpenType, WOFF); applying it to pages is still to come.
QuickJS runs page scripts with DOM access, scheduling helpers, events, fetch, element style updates and the CSSOM hooks needed by current pages and baselines, plus MutationObserver, Range, focus, document.currentScript and crypto.subtle (digests and HMAC; other algorithms are explicitly refused).
The current bridge exposes document.styleSheets,
style.sheet, cssRules,
insertRule, deleteRule, element.style
and getComputedStyle(). That is enough for the measured
local cases and selected WPT paths, but it is not a complete
CSSStyleSheet implementation.
A frozen selection of 933 files from the official Web Platform Tests suite serves as an engineering reference: every change to the engine is replayed against it to detect regressions. These runs measure specific engine features; they do not tell which websites work.
| Area | Current NativeX statement | Limit still declared |
|---|---|---|
| HTML | Parser and DOM behavior covered by local cases and WPT core work. | No claim of full browser conformance. |
| CSS2/CSS3 | Selectors, cascade, inheritance, colors, units, shorthand and resolved-value paths are measured. | Layout and paint remain separate from parser conformance. |
| CSSOM | Partial CSSOM bridge is present and writable for stylesheet rules. | Constructed stylesheets and complete CSSStyleSheet semantics are not claimed. |
| JavaScript | DOM-facing JavaScript, events, timers and fetch are active in Mathis and the demo client. | Only the exposed Web API subset is supported. |
The engine in a real application. The same engine runs the demonstration client and the in-development browser Mathis.
Media support is implemented below the UI layer so applications can use it without delegating basic formats to a large external runtime.
PNG, JPEG, GIF, BMP, TGA, SVG, ICO and animated WebP are available in the default path. AVIF decoding exists behind the build option because the default dependency cost is still under review.
Four file formats decoded to PCM: WAVE, MP3, native FLAC and Ogg Vorbis. Decoding opens no device and relies on no system codec; playback and capture do have explicit platform backends. A format that is recognised but not decoded is named rather than refused wholesale — container and codec are two separate answers.
Video decoding is connected to pages and Mathis viewers when enabled. Formats and codecs depend on the platform backend; streaming and DRM support remain limited.
The same application code targets all of these platforms. Their level of maturity differs, and we prefer to say so: available = used today by our applications; being ported = the system layer builds and passes its tests, the interface remains to be ported; per project = assessed with the customer, on their hardware.
The main development platform: Mathis, the demos and the full test suite run on it every day.
X11 windows, same libraries, same application code.
Cocoa windows, .app bundle and .dmg disk image.
The natural gateway to embedded: industrial prototypes, light operator panels, kiosks.
The reference real-time OS in industry. The NativeX system layer already builds on it, without a graphical interface.
The system layer builds with the NDK for 64-bit and 32-bit ARM and x86_64.
The system layer builds as a static library for iPhone and the simulator.
Yocto, Buildroot or an industrial distribution, on ARM or x86.
QNX for safety-critical industry, Zephyr or FreeRTOS for highly constrained devices.
NativeX is not trying to replace a full browser, a managed runtime or a game engine. It is built for applications that must stay lightweight, predictable and under control: industrial tools, operator HMIs, desktop software and, tomorrow, embedded devices.
| Criterion | NativeX | Embedded browser shell | Classic cross-platform UI toolkit |
|---|---|---|---|
| Runtime footprint | Small native stack, explicit dependencies | Large browser runtime | Depends on toolkit and plugins |
| UI description | XML rendered by native backends | HTML rendered by browser engine | Toolkit-specific DSL or code |
| Web standards | Measured subset, no global conformance claim | Full browser engine behavior | Usually delegated or unavailable |
| Resource model | Preallocation and steady-state discipline | Browser and JS runtime own most behavior | Depends on toolkit allocation model |
| Targets | Windows, Linux, macOS today; Raspberry Pi, VxWorks and mobile being ported | Web-first desktop apps | General-purpose desktop UI |
The planned distribution is an installable SDK: public headers, compiled libraries, documentation and examples. Framework sources are not offered for public download. Version 0.1 packages are built and verified internally; none is distributed yet, and no release date is announced.
Use NativeX through its public interfaces and libraries built for your platform and compiler. The first component, Core, covers the XML interface, controls, rendering and the C facade, as a static or shared library (Windows DLL, Linux .so, macOS .dylib). The web engine, printing and media are not part of it yet: they will be added module by module, once qualified.
Variants built: Windows x64 with MSVC and with MinGW, Linux x86_64 and ARM 64, macOS Apple Silicon. Each package is tied to its toolchain and runtime, specified for every delivery. Embedded and mobile targets are assessed per project.
One NativeX Setup installer per system and a relocatable CMake package: internally, an example copied outside the SDK configures, builds and runs against the installed SDK, without rebuilding the framework. The installers are still signed with a test key and are not distributed as they stand.
A getting-started guide, an API reference generated from the documented headers, standalone examples and deployment instructions ship with the internal packages. They will be provided with SDK access, not as public downloads.
Tell us your platform, compiler and application constraints. NativeX is a paid proprietary SDK with a 14-day trial; its terms will be those of the licence published at release.
Contact MoobotecThe SDK documentation explains how to build and deploy your application using the installed libraries. It ships with the SDK and will be provided with access to it; internal repository build scripts are not the public onboarding path.
Installation, selecting a compatible SDK variant, creating a project and building your first window.
Application lifecycle, controls, markup, events, memory ownership and threading constraints. Every public function is documented in the headers, from which the reference is generated.
Progressive projects using only the installed SDK: window, XML UI, controls and customization.
Runtime libraries, assets, compatible configurations and applicable redistribution terms.
Software that runs for weeks on a device must not grow. That is a NativeX rule, and it is tested.
Navigation, page closure, canvas, video playback, PDF, camera: after each cycle, memory and graphics surfaces must return exactly to their initial value. Verified on Windows.
To make sure a test is useful, we deliberately reintroduce the defects that were fixed: the tests must fail, then pass again once the fix is restored.
Linux and macOS for these latest tests, a physical camera (the tests use a simulated one) and real-time video reception, not yet built on Windows.
Status on 8 November 2026: what is done, what is partial, what is planned.
LIB_FrameworkNext replaced the historical third-party UI base in August 2026; XML UI, controls and rendering use the NativeX implementation.
The library web engine runs Mathis: loading and displaying real pages, scripts included, with embedded frames in their own process. New DOM and JavaScript interfaces arrive with each round of work; compatibility with websites remains partial.
Mathis provides persistent profiles, downloads and text, image, audio, video and PDF viewers. Formats, codecs and qualification vary by platform.
Shared networking, centralized allocators, cycle tests on navigation, canvas, video, PDF and captures. Linux, macOS and real hardware remain to be qualified.
Graphics foundations, audio and video decoding and their page integration are present. Real devices, streaming and backends require specific qualification.
Web policies, content processes, crash diagnostics and printing are integrated. Confinement, compatibility and hardware qualification limits remain explicit for each OS.
The installer generator supports Mathis packaging on Linux and macOS. This does not establish public distribution or availability of a Windows installer.
Version 0.1 packages built and verified internally on Windows (MSVC, MinGW), Linux and macOS: headers, static and shared libraries, CMake integration, installers, API reference and examples. Package signing, tests on clean machines and access terms remain; no public SDK download is announced.
Replay workflows on Windows, Linux and macOS, then prepare distribution packages. No general-availability schedule is announced.
Port the interface to Raspberry Pi and embedded Linux, then to VxWorks, where the system layer already builds. QNX and RTOS are assessed with the customer.
Each library carries its own SemVer source in VERSION.txt.
The product scope below is the current NativeX surface.
By the numbers. NativeX amounts to about 520,000 lines of C/C++ written by Moobotec, close to 20 MB of source code, tests included. It also integrates about 1.1 million lines of open-source components (network security, audio and video codecs, images). Once compiled as an optimized build, a complete application, such as the Mathis browser, weighs between 7 and 10 MB, with no dependency to install.
Licence. NativeX is paid proprietary software from Moobotec, with a 14-day trial. The Mathis browser, built with it, is free and gives no right to develop with NativeX. Third-party components keep their own licences; their attributions and, for those under MPL 2.0, their sources will ship with every package.
NativeX is paid proprietary software: a 14-day trial to evaluate it, then a commercial licence. The SDK is in preparation; its terms will be those of the licence published at release.
Note. The final amount depends on developer count, target platforms, service scope and support level. Contact us for a scoped quote.
Tell us about your product, constraints and target platforms. We can help with evaluation, porting, industrialization and production support.