Native C/C++ foundation · version 0.2.0, in development

One C/C++ foundation, from the desktop to embedded devices

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.

TodayWindows, Linux, macOS
Being portedRaspberry Pi, VxWorks, Android, iOS
Coming nextan SDK for your applications
Today · 8 November 2026

What NativeX already does

The best proof of a framework is the applications it runs. NativeX currently powers a complete web browser and several demonstration tools.

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.

A complete application, not a demo

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.

Memory that returns to zero

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.

Installers that work

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.

An engine catching up with today's Web

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.

Understanding a page that fails

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.

Tomorrow

What NativeX will enable

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.

Available

In our applications

  • Native interfaces described in XML on Windows, Linux and macOS.
  • A native web engine able to display real websites.
  • Images, audio, video and PDF without relying on a large external runtime.
  • HTTP/1.1, HTTP/2 and TLS networking in the foundation.
  • Linux and macOS installers generated by NativeX Setup.
Next step

In your applications

  • An installable SDK: headers, compiled libraries, CMake integration, already built and verified internally.
  • Build your application without rebuilding the framework.
  • Windows (MSVC, MinGW), Linux (x86_64, ARM 64) and macOS (Apple Silicon) variants.
  • Getting-started guide, API reference and buildable examples.
  • Evaluation access on request, commercial license.
Ambition

On your devices

  • The same application on Raspberry Pi and embedded Linux, with its interface.
  • A graphical interface on VxWorks, where the system layer already builds.
  • QNX and RTOS (Zephyr, FreeRTOS) assessed with the customer, on their hardware.
  • Android and iOS: the system layer builds, the interface remains to be ported.
  • A declared resource budget: zero allocation in steady state.
HMI

Operator HMIs

Control panels, supervision and diagnostic tools with a controlled footprint.

WEB

Embedded web content

Display help, dashboards or HTML pages without shipping Chromium.

APP

Desktop software

A lightweight native application, cleanly installed on all three systems.

OS

Porting existing code

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.

Ecosystem

Two libraries, one production pipeline

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.

NativeX - one build tree, one version, several targets
C

LIB_SysOs

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.

C11portableno heavy dependencies
UI

LIB_FrameworkNext

Native application and interface layer: XML layouts, controls, events, 2D/3D rendering, windows for each platform and an embeddable web engine.

C++17C facadeXML UI
DescribeXML, assets, data
=>
BuildCMake scripts
=>
Testunit, render, WPT
=>
PackageWindows, Linux, macOS
=>
InstallNativeX Setup
Capabilities

What is in the box

Every capability below exists in the code and runs in a demonstration application.

WEB

Mathis

A complete web browser built on NativeX: the most demanding demonstration of the framework.

XML

Declarative UI

Windows, panels, layouts, controls, commands and data are described once and rendered through native platform backends.

LAB

Framework Lab

A full demo app exercises widgets, menus, dialogs, list views, tables, text editing, docking and theme behavior.

HTTP

HttpClientGui

A demonstration HTTP client: it fetches a page, parses it, applies the CSS, runs the JavaScript and displays it, without an embedded browser.

SRV

WebServerGui

A demo server shows request handling, routing, response generation and practical UI integration for network tools.

GPU

Graphics engine

2D and 3D command lists can run through a GL backend or a recording device for headless tests.

XML

Interface editor

An XML editor with live preview, built on the same interface layer as applications.

API

C boundary

The interface engine keeps a C++ implementation and exposes a C facade where integration code needs a stable ABI-style boundary.

Gallery

Native applications built with the same stack

Real screenshots: the Mathis browser rendering this site, then the framework demos (controls, HTTP client, graphics, server tooling and XML editor).

Mathis browser built on NativeX
The Mathis browser, built on NativeX, rendering the Moobotec home page
App_FrameworkLab UI controls
NativeX Framework Lab demo application
HttpClientGui HTML / CSS / JS
NativeX native HTTP client and web preview
WebServerGui network tools
NativeX web server GUI demo
GraphicsShowcase 2D / 3D
NativeX graphics showcase
Interface editor XML
NativeX XML UI editor

Note. Screenshots are generated from the current demo applications and reused by the public site assets.

API

A native API surface with documented boundaries

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.

C11system layer
C++17interface engine
Cstable integration facade
0.2.0current product version

System layer

Files, memory, network, parsing, media and OS integration are handled by the C11 foundation.

LIB_SysOs_File_Open(...) LIB_SysOs_HttpClient_Get(...) LIB_SysOs_Json_Parse(...)

Application layer

The C++ framework owns widgets, rendering commands, input dispatch and higher-level application objects.

LF::Application app; // XML + public LF API // controls, events, rendering

C facade

Selected entry points are exposed through C headers for integration scenarios that do not want a C++ ABI boundary.

nx_rect_make(...) nx_rect_contains_point(...) nativex/capi/nx_core.h
Native web engine

HTML, CSS and JavaScript, written natively

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.

83local cases
80supported
3partial
0failed or crashed
HTML

HTML and DOM

HTML parsing, DOM tree construction, attributes, text nodes, events, selectors, forms, dataset, classList, named access and serialization are covered by tests and WPT work.

HTML5 subsetDOMevents
CSS

CSS2/CSS3 cascade

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.

CSS2CSS3 subsetsStyleEngine
JS

JavaScript bridge

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).

QuickJSDOM bridgefetch

CSSOM is partial, not absent

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.

Reference tests, not a marketing score

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

Images, audio and video are part of the native stack

Media support is implemented below the UI layer so applications can use it without delegating basic formats to a large external runtime.

IMG

Image codecs

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.

default codecsoptional AVIF
SND

Audio

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.

WAVEMP3FLACOgg Vorbisnamed refusal
MP4

Video files

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.

containerdecodermodule-dependent
Platforms

Where each platform stands

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.

Windows Available

The main development platform: Mathis, the demos and the full test suite run on it every day.

  • Native Win32 windows, built with Visual Studio (MSVC) or MinGW.
  • Web page isolation enabled by default in Mathis.
  • SDK built and verified internally in MSVC and MinGW variants, static and DLL.

Linux Available

X11 windows, same libraries, same application code.

  • Mathis builds, passes its tests and has a Linux installer (NativeX Setup).
  • Page isolation works differently and still has limitations.
  • SDK built internally for x86_64 and ARM 64 (glibc 2.31 or later).

macOS Available

Cocoa windows, .app bundle and .dmg disk image.

  • Mathis packaged as .app and .dmg by NativeX Setup.
  • Page isolation enabled by default.
  • SDK built internally for Apple Silicon; your applications are produced as .app bundles.

Raspberry Pi Being ported

The natural gateway to embedded: industrial prototypes, light operator panels, kiosks.

  • Cross-compilation for 64-bit and 32-bit ARM from a development machine.
  • System layer tests run under emulation, with the same results as on macOS.
  • Next step: the interface and qualification on a real board.

VxWorks Being ported

The reference real-time OS in industry. The NativeX system layer already builds on it, without a graphical interface.

  • Threads, timers, files, networking and logging adapted to VxWorks 7.
  • Built with the Wind River SDK, tested under QEMU emulation.
  • Ambition: the graphical interface, on the customer's hardware.

Android Being ported

The system layer builds with the NDK for 64-bit and 32-bit ARM and x86_64.

  • System layer tests run on a 64-bit ARM emulator with the same results as on desktop.
  • Interface and mobile packaging remain to be ported.
  • Goal: same application code, native mobile backend.

iOS Being ported

The system layer builds as a static library for iPhone and the simulator.

  • Warning-free builds, in Release and Debug.
  • UIKit interface and packaging remain to be ported.
  • Support available for signing and publishing.

Embedded Linux Per project

Yocto, Buildroot or an industrial distribution, on ARM or x86.

  • A natural starting point: the Linux backend already exists.
  • Toolchain, system image and display stack chosen with the customer.
  • Suited to kiosks, operator panels and gateways.

QNX and RTOS Per project

QNX for safety-critical industry, Zephyr or FreeRTOS for highly constrained devices.

  • QNX: porting study carried out with the customer's SDK.
  • Zephyr, FreeRTOS: system layer only (timers, logging, JSON, lightweight HTTP), with no interface promise.
  • These ports are offered as engineering services.
Compare

Where NativeX is intentionally different

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
SDK NativeX

A developer SDK, in preparation

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.

Public headers and libraries

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.

Desktop first

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.

Installation and CMake integration

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.

Documentation and examples

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.

Discuss your SDK requirements

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 Moobotec
SDK documentation

Documentation designed for SDK users

The 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.

Getting started

Installation, selecting a compatible SDK variant, creating a project and building your first window.

Public API

Application lifecycle, controls, markup, events, memory ownership and threading constraints. Every public function is documented in the headers, from which the reference is generated.

Examples you can build

Progressive projects using only the installed SDK: window, XML UI, controls and customization.

Application deployment

Runtime libraries, assets, compatible configurations and applicable redistribution terms.

Quality

Resources that return to their starting point

Software that runs for weeks on a device must not grow. That is a NativeX rule, and it is tested.

Measured on every cycle

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.

Tests that really detect

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.

What remains to qualify

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.

Roadmap

Progress and next steps

Status on 8 November 2026: what is done, what is partial, what is planned.

Interface engine rewrite Done

LIB_FrameworkNext replaced the historical third-party UI base in August 2026; XML UI, controls and rendering use the NativeX implementation.

Web engine integrated into Mathis Integrated

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.

Profiles, downloads and viewers Integrated

Mathis provides persistent profiles, downloads and text, image, audio, video and PDF viewers. Formats, codecs and qualification vary by platform.

Memory and resource control Verified on Windows

Shared networking, centralized allocators, cycle tests on navigation, canvas, video, PDF and captures. Linux, macOS and real hardware remain to be qualified.

2D/3D graphics and media Partial

Graphics foundations, audio and video decoding and their page integration are present. Real devices, streaming and backends require specific qualification.

Security, isolation and printing Partial

Web policies, content processes, crash diagnostics and printing are integrated. Confinement, compatibility and hardware qualification limits remain explicit for each OS.

NativeX Setup and Mathis distribution Partial

The installer generator supports Mathis packaging on Linux and macOS. This does not establish public distribution or availability of a Windows installer.

Installable developer SDK Built internally

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.

Cross-platform qualification and publication Ongoing work

Replay workflows on Windows, Linux and macOS, then prepare distribution packages. No general-availability schedule is announced.

Interface on embedded targets Ambition

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.

Versions

Component status

Each library carries its own SemVer source in VERSION.txt. The product scope below is the current NativeX surface.

NativeX superbuild
0.2.0
LIB_SysOs
0.1.0
LIB_FrameworkNext
0.1.0
Web bench
smoke / full
WPT smoke · Aug 2026
31 files
WPT core · Aug 2026
933 files

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.

Pricing

Two ways to adopt NativeX

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.

SDK
Trial
14 days
At SDK release · no commercial use
  • 14-day trial of the SDK, to evaluate it
  • Platform and compiler compatibility assessed
  • Guided demonstration by Moobotec
  • SDK documentation upon delivery
  • Commercial use and distribution of applications
  • Priority support and SLA

Note. The final amount depends on developer count, target platforms, service scope and support level. Contact us for a scoped quote.

Contact

Ready to accelerate a C/C++ application?

Tell us about your product, constraints and target platforms. We can help with evaluation, porting, industrialization and production support.