Introducing a content-addressed LLM and target engine that synthesizes cross-platform code, eliminates build cascades, and enables deterministic virtual machines via low-level binary isolation.

It was needed for for AwesomeOS a other big component of it is universal-git

• STEAL (Tactical Reallocation): Originally a military colloquialism—prominently within the U.S. Marine Corps—standing for Strategically Taking Equipment to Another Location. It represents the tactical commandeering or repurposing of critical gear across operational theaters when conventional logistics or bureaucracy fail to supply what is required.
• Sense (Intrinsic Discernment): An inherent capacity to perceive, decode, and derive operational meaning from raw phenomena. While biological perception spans sensory channels (from traditional senses to expanded perceptual states), computational systems process discrete informational units (bits). Merely possessing these bits does not confer coherence; true sense emerges only when informational components align into an intelligible essence.
• -cation (Systemic Transformation): A morphological suffix designating an automated, systematic, multi-pass exchange or transformation protocol (analogous to the credential negotiation and state transition cycles observed in authentication).
• Stealify (The Action): The strategic acquisition, repurposing, and optimization of external components or subsystems, executed with technical excellence and high operational impact.
• Stealification (The Process): The automated transformation pipeline operating between arbitrary source inputs and the Stealify metasystem. In mathematical and systems engineering terms, the resulting Stealified Product is the optimized composite entity obtained by evaluating and multiplying these independent structural factors together into an integrated whole.

The primary friction with the original Stealify Lang vision was not its technical foundation, but its conceptual scope. Teaching native ABI surface extraction, Content-Addressable Storage (CAS), linker interface synthesis, and AST pruners to developers accustomed to high-level scripting or coarse build scripts presented a steep learning curve.

With modern AI, that educational and tooling barrier disappears.

The LLM-integrated edition of Stealify Lang frees developers from the mechanics of build-graph orchestration, compiler plumbing, and linker script authoring. By operating directly on an Abstract Syntax Tree (AST) derived from a formal JSON/ECMAScript superset, it produces declarative, self-documenting code that is human-readable, machine-interpretable, and reusable across model contexts.

Stealify Lang was architected around a non-negotiable principle: absolute code and contract readability, especially for asynchronous workflows and native bindings.

Coupled with the Stealify Compiler v3 and our Smallest Common Denominator Strategy, the engine automates cross-platform compilation by decomposing targets into ABI-Sealed Components rather than monolithic binaries:

• Interface and Payload Decoupling: Downstream modules never link directly to unstable implementation binaries. The engine synthesizes lightweight Interface Stubs (.stub.so via llvm-ifs, .tbd for Apple, and .def/.lib via llvm-dlltool) containing only exported dynamic symbols.

• Semantic Early Cutoff: When internal private implementation details change, the public ABI interface digest remains identical. Linker and compilation passes across downstream components are pruned at machine speed, completely bypassing traditional recompilation cascades.

• Integrated Polyglot Toolchains: C++, Rust, CUDA, and WebAssembly compilation units are embedded directly within tagged ECMAScript template dispatchers (clang, rustc, nvcc), eliminating arbitrary shell wrappers, Makefiles, and GN files.

To guarantee true cross-platform hermeticity, Stealify Lang avoids host environmental variance and generic packaging runtimes.

The entire framework executes on b8g: our dedicated, low-level, statically linked V8 runtime.

• Built-in Low-Level I/O: Bare-metal system operations, process execution, and virtual memory isolation run natively without external runtime bloat.

• Zero External Dependencies: Built-in package management workflows eliminate fragmented dependency tooling.

• Deterministic Hermetic Execution: Builds evaluate inside hermetic, content-addressed sandboxes without requiring heavyweight Unix chroots or stateful container bind mounts.

Stealify Lang is not merely another build script, nor is it an isolated programming language. It is an AST-Driven Composition Metasystem capable of describing and generating any software target:

• High-Level Systems: Userland micro-services, reactive UI applications, and distributed edge runtimes.

• Native Component Boundaries: Dynamic FFI-bound shared libraries (.so, .dylib, .dll) and ABI-sealed components.

• Bare-Metal & Free Targets: Freestanding microkernels, firmware images, and isolated virtual machine layers.

By pairing this universal target model with autonomous LLM capabilities (an "LLM OS" pattern demonstrated in projects like Chromium Virtual Environments and AwesomeOS), systems are composed, audited, and patched through declarative intent rather than manual configuration.

• Local On-Device Execution: We are refactoring repositories across the organization to integrate local on-device models (including browser-native foundations such as Gemini Nano) directly into the development and validation loop.

• Zero-Setup AI Workspaces: All templates, prompt patterns, and component manifests will run directly inside your model context and b8g runtime without requiring auxiliary orchestration software.

• Open Science & Research Artifacts: Core compiler AST pruners, symbol extraction algorithms, and automated three-way patch rebasers will remain open for systems researchers.

Declare an ABI-sealed native component in standard ECMAScript syntax:

import { clang, cShared } from "@stealify/lang";
import { ExportMapEngine } from "@stealify/symbol-extractor";

// 1. Compile C++ translation unit with hidden symbol visibility
const engineComponent = await cShared("-target x86_64-linux-gnu -O3 -fvisibility=hidden")`
  #include <iostream>

  // Public ABI Contract
  extern "C" __attribute__((visibility("default")))
  int start_subsystem() {
    std::cout << "Subsystem running under pure b8g execution." << std::endl;
    return 0;
  }

  // Internal implementation detail (automatically pruned from interface stubs)
  void internal_alloc() {
    // Unexported logic
  }
`;

// 2. Synthesize platform linker stubs (.ifs / .stub.so / .def) for consumers
const engine = new ExportMapEngine({
  libraryName: "libsubsystem.so.1",
  whitelistPatterns: [/^start_subsystem$/],
});

await engine.buildAll([engineComponent.path], "./stubs");

Run directly through b8g:

b8g run ./engine.component.ts

Stealify Lang turns the traditional native software stack—from userland to kernel—into a self-describing, content-addressed polyglot component graph.

Introducing an LLM that produces cross-platform code and enables the creation of virtual machines via binary sandboxing.

The biggest challenges and problems with the Stealify Lang project were its significant impact and the complexity of teaching these concepts. Previously, I found no good way to accomplish this, but today, with AI, it is more possible than ever to educate both regular coders and consumers.

The LLM version of Stealify Lang frees you from the intricacies of language implementation, leaving you with only readable, interpretable, and even LLM-reusable code.

Stealify Lang was designed from the ground up with one major goal: code readability, particularly for asynchronous code. Readability is the most critical quality criterion for code.

Together with the overall Stealify Compiler v3, which exists today, we can refactor software based on an LLM into multiple software deployments using the Smallest Common Denominator Strategy. This strategy, which I invented for software development at scale, has proven effective.

The language research has indeed paid off. With the reduction of entry barriers for AI on consumer hardware, there is no longer a need to create hardcoded integrations into existing stacks. We can now use LLM capabilities as a so-called LLM OS. This was proven with the Chromium Virtual Environments Project and AwesomeOS.

We will refactor all repositories and this organization to allow the usage of Gemeni Nano, which is shipped with Chrome 227, and some repositories will be left for researchers.

Everything will be usable in your LLM without additional software. We will only publish some reduced versions of prompt patterns and techniques, as well as broader context about the current state of open source code and more.

The Stealify Lang LLM revolutionizes cross-platform coding by simplifying language implementation and enhancing code readability, particularly for asynchronous code. By leveraging AI, it reduces entry barriers and eliminates the need for hardcoded integrations. The introduction of Gemeni Nano and ongoing repository refactoring ensure seamless use without additional software, advancing the state of open source coding and development.

A Set of Tools to Produce Cross Platform Arch Software with confidence including Web Driven Apps and Web Platforms as also Operating Systems. In general Stealify means To steal something in sense of doing awesomely. (a term invented by Frank Lemanschik) as also Stealifycation and Stealifyed.

It works with all kind of languages. In all kinds of Variations embedded and embedding. c++, rust, wasm, zig.

It also Ranks #1 in EMPOWERTECH Benchmark over any rust and c++ framework so it is able to build ultra fast Distributed Databases and Applications. Via adapters for Couchbase, Cassandra, Kafka and its buildIn ability to integrate any language it is the perfect fit to code create run and maintain your next cloud platform or cloud project. But it is also the Perfect fit to even create small integrated system platform utils that automate system tasks it is also IoT embedded Ready.

that allows you to code Interface Definition Languages in a declarative way. To make your development and build processes more simple on a fundamental level that leads to higher code reuse and convidence that the project fullfills all needed requirments that are even subject to change over time. It helps you to create Portable Applications based on own IDL's so you will get familar with the concept of creating a own domain related language that is Readable and useable to Compose your whole Application. Everything that you solved with a tool before gets solved with a Language Module.

Make changes to your source code iteratively, using hot reload to instantly see the effect in the running app Write code using a flexible type system with rich static analysis and powerful, configurable tooling Do profiling, logging, and debugging with your code editor of choice.

It also mainly Teaches you generic interfaces used via generic methods to make your life as a Coder more Enjoyable and save this Framework and its methods make any existing Language Memory Save and it adds a lot of Extra features that are not obvious at the first time. You can dig Many years into the details that leaded to this work and the state it is now or you can simply take it and understand over time why this made you a better coder.

It inhirets research from other languages and the implementers that wrote them like: GraalVM and Truffle and all Java Langs eg kotlin, Go, Dart, Rust, Zig, Meson, Many Open Source API's, GRPC, CapNProto....

It Alligns all the pros of all this implementations into one generic learn able simple way.

Use Stealify Lang inside any Editor That Supports JavaScript/Typescript most best VSCODE configured to allowJs and checkJs by default. or Alternativ our own Stealify Edition of Unlicense Code a successor Project of Code Oss which is the fundation of many Editors. Unlicense Code is a Set of Code Compiler and Tooling repos to build tools to build applications.

The main goal of this project is a world where everything is under The Unlicense. As usage and education and keeping up with needs are hard enough to keep competition out of every market we do not need to make other people's life harder than it needs to be only because of some weird Idologic reasons. To reach that goal we needed a Framework for the Process that is the Stealify Component System it is based on

We Enforce some high level principels to make your code more maintainable. You can google the terms from the above headline as i do not need to copy existing references at present. also see builtIn Features Section to get a grasp of what your getting here.

• Advisory Components a way to create Interface driven Advisory on Anything
  • Do stuff like installations, configurations, deployments, optimizations of costs, any thing a good consultant offers.
• CodeMod Components a way used most by Adivsory Components to introduce changes to existing code.
• reduces the amount of production code
• and reduces the amount of development source code
• making you a better programmer.
• reduces the number of failures and confusion while creating software.
• a completely new system designed from scratch taking only the parts of Open Source that make sense.
• allowing you to isolate software parts that make sense into independent components that run anywhere.
• leads to reusable code by design none reusable code is for example code that is so highly abstracted that you would skew your head off when you would understand and know what happens.

• Steal is A little-known term used in the U.S military, typically used in the U.S. Marine Corps which stands for Strategically Taking Equipment to Another Location. It is a term used to justify taking something that doesn't belong to you when questioned by a superior who feels the action is immoral. STEALing most likely occurs while on deployment to a faraway country.
• sense Is something you can make, but only if you are born with it, although everyone has 7, some people can have 8 or more as well let us say 16. You can also have a sense of something eg bits, but even having all these bits doesn't mean everything makes sense. Got that? hint: - If not replace "in sense" with "in essence" then it makes sense.
• cation references to a technical exchange process you see that with other words like authentication which is a word that describes that there happens a multi-pass exchange process of user data.
• so Stealify means To steal something in sense of doing awesomely.
• and Stealification is the Automated exchange process between code and stealify that leads to a Stealifyed Product in mathematics, a product is the quantity obtained by multiplying two or more factors together.

See: Emerging-Technologies

• https://github.com/direktspeed/opfs/desktop/commander
• https://github.com/direktspeed/opfs/cli tools for legacy Shells
• https://github.com/direktspeed/opfs/tty the new main shell terminal system
• https://github.com/direktspeed/awesomeos/host a VFS Kernel based Operating System for compatability with legacy tools using v8 as ring 0
• https://github.lemanschik.com/experiments
• https://stealify.github.dspeed.eu
• https://profile-page.stealify.github.dspeed.eu
• https://b8g.github.dspeed.eu
• https://vsstudio.github.dspeed.eu

We would suggest you to use VSStudio as entrance point into the ecosystem as it is composed out of all core parts and is used to streamline the assembling of stealify it self. It is at present largly dependent on vscode and our own editor @stealify/editor we merge port partial everything over to our own editor as it is based on better concepts and patterns. It is a Component Driven Editor not only for code for anything it offers generic interfaces like mouse movement keyboard interactions and is also reactive to its viewport and allows to get embedded integrated into anything that needs to track detailed interactions with a text box or fild in general.

• - stealify:compiler a guiding compiler implementing the latest greatest LTO and PGO as also adds Observability via Instrumentation.
• - npm:@stealify/compiler
• - quick-start - a collection including nodejs, electron, nwjs, graaljs, chromium, systemd, libcontainer, vmm, fiddle
• - stealify:components - a whole registry of stealify:*
• - stealify:language-server
• - npm:@stealify/language-server a program able language server integration for IDE's
• - stealify:-@version
• - npm:@stealify/-@version