Daslang (former daScript) is a high-level programming language that features strong static typing. It is designed to provide high performance and serves as an embeddable 'scripting' language for C++ applications that require fast and reliable performance, such as games or back end/servers. Additionally, it functions effectively as a standalone programming language.

Overview

Daslang is:

• Extremely fast programming language that can rival compiled or JIT languages even in interpreter mode. It consistently outperforms dynamically interpreted scripting languages such as Lua. When used in AOT mode, Daslang is often faster than naively written C++ due to its SSE-friendly POD-types, and it even surpasses some of the best JIT VMs like V8 or LuaJIT. As a result, there's no need to rewrite your Daslang code in C++ to optimize your application.
• Safe and versatile programming language that provides all the benefits of static typing. Many errors that would break an application in runtime in languages like Lua or JavaScript won't even compile in Daslang. Additionally, due to its support for generics, type inference, and macros, Daslang is easy and fluid to use. Safety is a fundamental pillar of Daslang's design, making it safer in many cases than languages like C++ or Java.
• Real embedded programming language that requires no external dependencies other than a C++17 compiler. Its interop capabilities are both super easy to use and safe, as is expected from any embedded scripting language that's meant to call native code.

Daslang offers a wide range of features like:

• amazing performance
• strong static typing
• instant hot reload
• Ruby-like blocks
• semantic indenting
• lexical scoping
• high performance interpretation
• Ahead-of-Time compilation (optimization for release build)
• generators
• generics and type inference
• macros
• optional types (i.e. pointers)
• native HW friendly POD types
• C++ friendly and fast interop
• semi-manual memory management
• fast and easy-to-reset execution context, allowing automatic burst free memory management for stored procedures
  no memory leaks with no GC/reference counting cost.
• extendable type and function system
• cheap multi-threading support - explicit separation of execution context and code context.
• Open Source BSD licence
• powerful embedding API
  • e.g. functions can be defined by scripts or in C++
  • e.g. objects can fully exist in the Context or be bound to native code
  • and more

Daslang takes inspiration from languages like Python, Ruby, Kotlin, and Haxe when it comes to its explicitness and readability. However, it is also designed to be extremely fast, making it an ideal choice for performance-critical applications.

A Visual Studio Code extension is available for Daslang, providing comprehensive support for the language. This extension offers features such as code diagnostics, code completion, code navigation, hints, and more. Additionally, it provides a rich debugging environment, allowing developers to easily debug their Daslang code. It also includes a profiler for measuring and optimizing code performance. You can find this extension on the Visual Studio Code Marketplace at the following link: https://marketplace.visualstudio.com/items?itemName=profelis.dascript-plugin.

What Does it look like?

Daslang's syntax is reminiscent of Kotlin and (Typed) Python, while its static strong typed nature is similar to ML or Zig. Its POD types are closely aligned with hardware/machine types. Additionally, the language makes use of type inference, as can be seen in the following Fibonacci code snippet.

def fibR(n) {
    if (n < 2) {
        return n
    } else {
        return fibR(n - 1) + fibR(n - 2)
    }
}
def fibI(n) {
    var last = 0
    var cur = 1
    for ( i in 0..n-1 ) {
        let tmp = cur
        cur += last
        last = tmp
    }
    return cur
}

options gen2=false

def fibR(n)
    if n < 2
        return n
    else
        return fibR(n - 1) + fibR(n - 2)

def fibI(n)
    var last = 0
    var cur = 1
    for i in 0..n-1
        let tmp = cur
        cur += last
        last = tmp
    return cur

Development state

Daslang's current version is 0.6 (or just about), and it's already being used in production projects at Gaijin Entertainment. Until the release of version 1.0, there will be no patches or fixes for older versions. Instead, all updates and fixes will be made available exclusively in the master branch.

Daslang has been successfully compiled and run on a wide range of platforms, including Windows (x86 & x64), Linux (x64), macOS, Xbox One, Xbox One Series X, PlayStation 4, PlayStation 5, Nintendo Switch, iOS, Android, and WebAssembly.

Has been tested with the following compilers with C++17 support:

MS Visual C++ 17, 19, and 22 (x86 & x64)
Linux GCC
LLVM 7 and above

To compile, Daslang requires support for C++17.

Performance

Interpreted  |  AOT or JIT

As an interpreted language, Daslang typically outperforms everything, including the blazing fast LuaJIT.

Daslang particularly excels in interop with C++ functions, providing an easy and seamless experience when it comes to integrating new functions and types.

The overhead of data-oriented processing in interpretation mode in Daslang is comparable to C++ in Debug mode, as demonstrated by the Particles sample.

Interpreted

dictionary

exp loop

fibonacci loop

fibonacci recursive

float2string

mandelbrot

n-bodies

native loop

particles kinematics

primes loop

queen

sha256

sort

spectral norm

string2float

tree

As a compiled Ahead-of-Time language, Daslang is significantly faster than both LuaJIT and Chrome JS, both of which have extremely fast Just-in-Time compilers.

In terms of performance, Daslang is nearly on par with naive C++ (compiled with clang-cl llvm 8.0.1 with all optimizations), typically differing by no more than 10%. In some cases, Daslang can even outperform C++.

Daslang Just-in-Time compilation is based on LLVM backend, and often outperforms C++, due to Daslang providing more information to LLVM than AOT.

It is worth noting that unlike Just-in-Time compilation, Ahead-of-Time compilation can be used on any platform, including those with signed binary executables like iOS or consoles.

AOT or JIT

dictionary

exp loop

fibonacci loop

fibonacci recursive

float2string

mandelbrot

n-bodies

native loop

particles kinematics

primes loop

queen

sha256

sort

spectral norm

string2float

tree

All samples for all languages in comparison are available in GitHub

Change List

0.6.1 (April 2026)

VSCode Extension: dastest Integration

Run tests and benchmarks directly from the editor — inline buttons, Test Explorer panel, per-test pass/fail feedback without leaving the IDE.

• Inline run buttons for individual tests and benchmarks
• Test Explorer integration with per-test results
• JIT and isolated mode setting toggles (read fresh each run, no reload needed)
• Live stdout/stderr streaming during tests (previously silent until completion)
• Cross-platform compiler auto-detection
• Better error messages (compiler not found vs dastest not found)
• dastest isolated mode fixes (forward --bench, full per-test JSON results)

daspkg: Package Manager

• Full-featured package manager built entirely in daslang
• Commands: install (local/git/index), update, upgrade, remove, build, check, list, doctor, introduce, withdraw
• .das_package manifests — executable daslang scripts (not static JSON) with SDK-aware build logic, conditional steps, programmatic version checks
• Dependency resolution — transitive deps, semver constraints (>=1.0,<2.0), version/branch pinning, cycle detection, update rollback
• Global install — --global installs to das_root/modules/, shared across projects; auto-use compatible global versions; shadow detection
• Native module builds — CMake-based automatic compilation with doctor for toolchain validation
• Ecosystem migration — dasImgui, dasImguiNodeEditor, dasMinfft, dasTelegram extracted from submodules to standalone daspkg packages
• 4 example packages: ImGui, node-editor, minfft, Claude API Telegram bot
• 151 unit tests + 70 integration tests

daslang-live: Live-Reloading Application Host

• New daslang-live.exe — compile/init/update/shutdown lifecycle, automatic GC, hot reload on file changes
• 6 live modules (live_commands, live_api, live_watch, decs_live, glfw_live, opengl_live)
• @live macro replaces ~60 lines of manual reload boilerplate
• REST API with help endpoint, error guard (503 on compile/exception errors)
• Exception recovery — clears corrupted persistent store, recovers on reload
• Single-instance enforcement, dependency file watching, -cwd flag
• 9 examples including Arcanoid (full 3D Breakout) and Sequence (board game with 3 AI bots)

AST Pattern Matching: daslib/ast_match

• Pattern matching on compiled AST using qmacro tags in reverse ($e, $v, $i, $t, $c, $f, $b, $a)
• Three macros: qmatch, qmatch_block, qmatch_function
• Wildcards, comprehension matching, block/lambda/local-function discrimination
• 305 tests, full language reference documentation

Compiler-Free Standalone Executables

• Builtin .das moved to daslib/ — all built-in .das wrappers eliminated from compileBuiltinModule
• Standalone exes no longer need the compiler — libDaScript can be split into runtime-only and compiler libraries
• Minimal runtime — possible to run daScript contexts with only C++-bound modules, no .das parsing at all
• ~10ms faster compilation on static builds (35ms → 25ms for hello world), ~7ms on dynamic

Performance Lint: daslib/perf_lint

• 9 rules: PERF001–PERF009 (string concat in loop, character_at usage, push without reserve, unnecessary conversions, redundant move-init)
• Expression chain walking, closure-aware, inferStack reporting
• Auto-lint via require daslib/perf_lint or standalone batch tool

More New Features

• Pointer safe-at — a?[index] for pointer types, returns null if pointer is null (interpreter, AOT, JIT)
• C API type introspection — ~40 new C functions to query struct layouts, enum values, function signatures
• New builtins — get_module_file_name, get_key (O(1) table value-to-key), first_character, with_das_string, system(), daslib/command_line

daStrudel: Pattern Music Engine

• SF2 SoundFont support — load General MIDI soundfonts, 128 GM presets, per-voice reverb/chorus sends, exclusive class/cut groups, note-off scheduling
• Two-mode player — main-thread mode (strudel_tick from render loop, direct pianoroll/PCM access) and threaded mode (headless audio, channel-based commands)
• Clean API — no StrudelState pointer passing, functions operate on per-context globals, strudel_add_track returns integer index
• Visualizer combinators — pianoroll(), spectrum(), scope(), vectorscope(), drums() as pass-through pattern pipes with rolling index
• MIDI player — load and play .mid files through SF2, per-channel gain/pan, looping, audio visualization channels
• Accurate timing — integer sample accumulation (no float drift), consumed_position hardware clock for visualization sync
• 6 demos: player, synth (100% generated), SF2 chill beat, piano (Ode to Joy), live-reload, OpenGL visualizer with 5-track pianoroll/spectrum/drums

Performance

• Faster CondFolding — optimizer handles multiple transforms per pass
• Bulk DECS creation — create_entities ~10x faster (174ns vs 1772ns for 1000 entities)
• Optimized character_at — scans to index instead of full strlen

MCP Server (AI Tools)

• 7 new live tools for controlling daslang-live from AI assistants
• lint tool runs both paranoid lint and perf_lint in one pass
• shutdown tool, failures_only param for run_test
• Fix ast-grep venv detection, standalone exe subprocess hang, temp file collisions

Bug Fixes

• AOT das_null_coalescing wrong type source
• ASAN support on MSVC (missing __declspec, libhv flag forwarding)
• ModuleGroup use-after-free in daslang-live
• Fuzzer-found crashes (clone/ascend, type-macro size queries)
• Fusion ASAN false positives
• Cross-platform path hardcoding in tests
• JIT standalone exe fixes, JIT node coverage
• Array/table lock access flags
• Handled const string type emission

File I/O

• Explicit error reporting — Go-style string error out-params on 16 filesystem functions
• Fixed stat/fstat side effects annotation

stb Libraries

• stbtt glyph shape API exposed
• Two-layer safe stb_truetype API (70 tests, zero unsafe in high-level Font methods)

Documentation & CI

• Full daslang-live RST documentation
• CMake install overhaul (complete examples, modules, tutorials, utilities)
• Updated CLI help for all command-line switches
• Custom CI runners (Linux/Windows fat, macOS xlarge)
• Extended CI checks, correct timeouts
• Codebase-wide lint sweep (daslib, modules, examples, tutorials)

Documentation

Daslang 0.6

Online Daslang 0.6 reference manual and Standard Libraries manual

Offline Reference Manual (PDF)
Offline Standard Libraries Manual (PDF)

Try it online!

Try it in your browser implemented with Emscripten, runs in your browser.
Try it online implemented with tio.run fork.

Downloads and links

Latest release

Daslang latest release 0.6.0 can be found on GitHub.

GitHub Repository

Daslang's GitHub repository is here

Authors blog

Boris Batkin blog on Daslang (in English)

Other useful links

Language server plugin for VSCode with auto-completion, help, etc - itself written in Daslang.
dasBox - simple framework allowing create games in Daslang.
Edenspark - Open Source AI-assisted platform for making games on PC and consoles.
Article on history of Daslang.
Spiiin's blog on Daslang (in Russian)