5. Embedding and Integration

This section explains how to embed the daslang scripting language into a host application written in C++ or C (and, by extension, any language that can call C functions). It is organized from simple to advanced:

• Quick Start — minimal host program, compilation, and evaluation

• C++ API Reference — modules, function/type/enum bindings, cast infrastructure

• C API Reference — the daslang/c_api/c_api.h header for C-only hosts and FFI

• External Modules — building and distributing modules outside the main source tree, .das_module descriptors, find_package(DAS)

• Project Files — .das_project files for custom module resolution and sandboxing

• Advanced Topics — AOT compilation, standalone contexts, class adapters

For step-by-step walk-throughs with complete, compilable source code, see the C++ integration tutorials and C integration tutorials.

• 5.1. Quick Start
  • 5.1.1. Virtual machine overview
    • 5.1.1.1. Execution context
  • 5.1.2. Minimal host program
  • 5.1.3. Key types
  • 5.1.4. Calling daslang functions with arguments
  • 5.1.5. Next steps
• 5.2. C++ API Reference
  • 5.2.1. Creating a module
    • 5.2.1.1. ModuleAotType
    • 5.2.1.2. Embedding daslang source in modules
    • 5.2.1.3. Builtin module constants
  • 5.2.2. Binding C++ types
    • 5.2.2.1. ManagedStructureAnnotation
    • 5.2.2.2. DummyTypeAnnotation
    • 5.2.2.3. ManagedVectorAnnotation
    • 5.2.2.4. ManagedValueAnnotation
    • 5.2.2.5. TypeAnnotation virtual methods
  • 5.2.3. Cast infrastructure
  • 5.2.4. Binding C++ functions
    • 5.2.4.1. addExtern + DAS_BIND_FUN
    • 5.2.4.2. Binding C++ methods
    • 5.2.4.3. Binding operators
    • 5.2.4.4. addInterop — low-level binding
  • 5.2.5. Binding C++ enumerations
  • 5.2.6. Function side effects
  • 5.2.7. Callbacks — blocks, functions, lambdas
  • 5.2.8. File access
  • 5.2.9. Project file resolution
• 5.3. C API Reference
  • 5.3.1. When to use the C API
  • 5.3.2. Initialization and shutdown
  • 5.3.3. Text output
  • 5.3.4. File access
  • 5.3.5. Compilation
    • 5.3.5.1. Compilation policies
  • 5.3.6. Simulation and context
  • 5.3.7. Function evaluation
    • 5.3.7.1. Aligned (vec4f)
    • 5.3.7.2. Unaligned (vec4f_unaligned)
    • 5.3.7.3. Complex results (cmres)
  • 5.3.8. Argument helpers
  • 5.3.9. Calling lambdas and blocks
  • 5.3.10. Binding C functions
  • 5.3.11. Binding types
    • 5.3.11.1. Structures
    • 5.3.11.2. Enumerations
    • 5.3.11.3. Type aliases
  • 5.3.12. String allocation
  • 5.3.13. Context variables
  • 5.3.14. Type introspection
    • 5.3.14.1. Querying variable types
    • 5.3.14.2. Navigating composite types
    • 5.3.14.3. Struct layout
    • 5.3.14.4. Enum values
    • 5.3.14.5. Function signatures
  • 5.3.15. Serialization
  • 5.3.16. AOT checking
  • 5.3.17. Module groups
  • 5.3.18. Side effects
• 5.4. External Modules
  • 5.4.1. Overview
  • 5.4.2. Module types
  • 5.4.3. The .das_module descriptor
    • 5.4.3.1. Registration functions
    • 5.4.3.2. Complete examples
  • 5.4.4. Module resolution order
  • 5.4.5. Building a C++ module
    • 5.4.5.1. C++ module class
    • 5.4.5.2. C module (using the C API)
    • 5.4.5.3. CMake setup
    • 5.4.5.4. AOT for external modules
  • 5.4.6. Building a pure daslang module
  • 5.4.7. Using an external module from a host application
    • 5.4.7.1. Dynamic module discovery
  • 5.4.8. Installing external modules
  • 5.4.9. Example: dascript-demo
  • 5.4.10. In-tree modules vs external modules
• 5.5. Project Files (.das_project)
  • 5.5.1. How it works
  • 5.5.2. Using project files
    • 5.5.2.1. From the command line
    • 5.5.2.2. From C++
    • 5.5.2.3. From daslang (runtime compilation)
  • 5.5.3. Writing a project file
    • 5.5.3.1. Minimal example
    • 5.5.3.2. DAS_PAK_ROOT
    • 5.5.3.3. Including other project files
  • 5.5.4. Callback reference
  • 5.5.5. Sandboxing example
• 5.6. Advanced Topics
  • 5.6.1. AOT compilation
    • 5.6.1.1. AOT pipeline overview
    • 5.6.1.2. AOT annotations
    • 5.6.1.3. AOT template functions
    • 5.6.1.4. AOT type customization
  • 5.6.2. Class adapters
    • 5.6.2.1. Pattern overview
  • 5.6.3. Coroutines (generators)
    • 5.6.3.1. Consuming a generator
  • 5.6.4. Dynamic script generation
    • 5.6.4.1. Context variables
  • 5.6.5. Standalone contexts
  • 5.6.6. Serialization
  • 5.6.7. Sandboxing
  • 5.6.8. File access customization