Metadata-Version: 2.1
Name: daslang
Version: 0.6.4
Summary: High-performance statically-typed scripting language for games and real-time applications
Home-page: https://daslang.io
Author: Gaijin Entertainment
License: BSD-3-Clause
License-File: LICENSE
Project-URL: Homepage, https://daslang.io
Project-URL: Source, https://github.com/GaijinEntertainment/daScript
Project-URL: Documentation, https://daslang.io/docs
Requires-Python: >=3.8
Classifier: Programming Language :: Other
Classifier: License :: OSI Approved :: BSD License
Classifier: Topic :: Software Development :: Compilers
Classifier: Topic :: Software Development :: Interpreters
Classifier: Operating System :: Microsoft :: Windows
Classifier: Operating System :: POSIX :: Linux
Classifier: Operating System :: MacOS
Description-Content-Type: text/markdown

# daslang

**daslang** (formerly daScript) is a high-performance statically strongly typed programming language. It can be used standalone or embedded into a C++ host application, and is designed for games and real-time applications.

- **Version:** 0.6.4
- **Release date:** TBD
- **License:** BSD 3-Clause

## Links

- **Website:** <https://daslang.io/>
- **Repository:** <https://github.com/GaijinEntertainment/daScript>
- **Documentation:** <https://daslang.io/doc/>
- **Blog:** <https://borisbat.github.io/dascf-blog>
- **Playground:** <https://daslang.io/#sandbox>
- **Authors:** Gaijin Entertainment

## Key Features

- High-performance - close to C++ speed via ahead-of-time (AOT) compilation and optional JIT (via LLVM)
- Strong static typing with type inference
- Generics, macros, and compile-time meta-programming
- First-class iterators, generators, lambdas, and closures
- Pattern matching, LINQ-style queries via standard library
- Native C++ interop - easy embedding and binding
- Hot reloading support for rapid iteration
- Cross-platform - Windows, macOS, Linux, WASM

## What's in the Box

| Directory    | Contents                                              |
|--------------|-------------------------------------------------------|
| `bin/`       | Compiler and tool binaries (`daslang`, `daslang-live`) |
| `lib/`       | Static and shared libraries for embedding             |
| `include/`   | C++ headers for integration                           |
| `daslib/`    | Standard library modules (`.das` files)               |
| `modules/`   | Optional plugin modules                               |
| `examples/`  | Example scripts                                       |
| `tutorials/` | Language, integration, and module tutorials           |
| `dastest/`   | Test framework (usable for testing your own code)     |
| `utils/`     | Tooling: MCP server for AI assistants (`mcp/`), LSP server for Claude Code (`lsp/`), package manager (`daspkg/`), lint (`lint/`), code formatter (`das-fmt/`), duplicate detector (`detect-dupe/`), coverage (`dascov/`), AOT/JIT helpers |
| `skills/`    | AI-assistant task instructions (paired with the root `CLAUDE.md`); `skills/daslang/` is the standalone language reference, auto-loaded for agent sessions at the SDK root and copyable into any project's `.claude/skills/` |
| `tree-sitter-daslang/` | Tree-sitter grammar, shared library, and highlighting queries |

## Quick Start

New to daslang? `GETTING_STARTED.md` (next to this file) walks through
running a first program and wiring up editor + AI-assistant tooling.

Run a script:

```sh
bin/daslang examples/hello_world.das
```

AOT-compile a script:

```sh
bin/daslang -aot examples/hello_world.das hello_world_aot.cpp
```

## Embedding via CMake

```cmake
find_package(DAS REQUIRED)
target_link_libraries(your_app PRIVATE DAS::libDaScript)
```

See `tutorials/integration/` for complete C and C++ embedding examples.

## Embedding without CMake

`DAS::libDaScript` pulls in the rest of the link set automatically; a hand-wired
project (a plain Visual Studio project, a custom build system) must list it all.
The daslang runtime is split out of the compiler library, so linking
`libDaScript` alone fails with unresolved symbols such as
`das::ptr_ref_count::ref_count_track` - the runtime half defines them.

Link, from `lib/`:

```
libDaScript.lib  libDaScript_runtime.lib  libUriParser.lib
```

plus, on Windows, the system libraries:

```
dbghelp.lib  ws2_32.lib  mswsock.lib  advapi32.lib  rpcrt4.lib
```

Add `include/` to the include path and compile as C++17 or newer. On
non-Windows platforms the same three daslang libraries apply, with the platform's
usual thread and dl libraries in place of the Windows list.

## Tree-sitter Grammar

A full tree-sitter grammar for daslang is included in `tree-sitter-daslang/`. Use it for:

- **Syntax highlighting** - `tree-sitter-daslang/queries/highlights.scm` works in editors that support tree-sitter (Neovim, Helix, Zed)
- **Parse-aware search** - via [ast-grep](https://ast-grep.github.io/) (`sg`) for structural code search. Install `sg`, then run from the SDK root (where `sgconfig.yml` lives):
  ```sh
  sg run -p "symbol_name" -l daslang
  ```
- **Editor extensions** - `tree-sitter-daslang/zed-daslang/` includes a Zed extension

## MCP Server (AI Tool Integration)

`utils/mcp/` contains an [MCP](https://modelcontextprotocol.io/) server exposing 40+ compiler-backed tools to AI coding assistants: compilation diagnostics, type inspection, go-to-definition, find-references, AST dump, AOT generation, expression evaluation, parse-aware grep for both `.das` and C++, duplicate detection, live-reload control, and more. Uses stdio transport - no extra build dependencies.

Configure in `.mcp.json`:
```json
{
  "mcpServers": {
    "daslang": {
      "command": "bin/daslang",
      "args": ["utils/mcp/main.das"]
    }
  }
}
```

See `utils/mcp/README.md` for the full tool list and permissions setup.

## LSP Server (Claude Code)

`utils/lsp/` contains a language server for `.das`: **push diagnostics** - the
compiler and lint report after every edit with no explicit tool call - plus
definition / references / hover / document & workspace symbols / call
hierarchy / go-to-implementation. Requires `python3` on `PATH`.

Claude Code sessions started at the SDK root load it automatically (the
shipped `.claude/skills/daslang-lsp/` plugin manifest). From anywhere else,
register it explicitly:

```sh
claude --plugin-dir <sdk-root>/utils/lsp/plugin
```

See `utils/lsp/README.md` for configuration (`initializationOptions`:
compiler override, `project_root` for native modules, `.das_project`).

## Building from Source

```sh
git clone --recurse-submodules https://github.com/GaijinEntertainment/daScript.git daslang
cd daslang
cmake -Bbuild -DCMAKE_BUILD_TYPE=Release
cmake --build build --target daslang --config Release
```

## macOS: Gatekeeper Quarantine

If macOS blocks the downloaded SDK with errors like *"cannot be opened because the developer cannot be verified"* or *"is damaged and can't be opened"*, remove the quarantine attribute:

```sh
xattr -cr /path/to/daslang-sdk
```

Binaries produced by `cmake --install` are ad-hoc code signed automatically, which prevents this issue in most cases.

## License

BSD 3-Clause License - Copyright (c) 2018-2026, Gaijin Games Kft.
See `LICENSE` for the full text.
