{"id":29052771,"url":"https://github.com/tinybiggames/jetvm","last_synced_at":"2026-01-20T16:28:49.203Z","repository":{"id":301296891,"uuid":"1008791801","full_name":"tinyBigGAMES/JetVM","owner":"tinyBigGAMES","description":"🚀 JetVM - Fast Delphi Virtual Machine High-performance stack-based VM with tagged union values, fluent bytecode generation. Features Pascal parameter modes (const/var/out), validation levels, native function integration, memory management, and real-time debugging. Perfect for embedding scripting capabilities! ⚡🎯🛡️","archived":false,"fork":false,"pushed_at":"2025-06-27T11:26:35.000Z","size":314,"stargazers_count":29,"open_issues_count":0,"forks_count":3,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-08-17T07:36:02.862Z","etag":null,"topics":["bytecode","debugging","delphi","dsl","embedded","execution-engine","fluent-interface","high-performance","native-functions","object-pascal","pascal","runtime","scripting","stack-based","virtual-machine","win64","windows-11"],"latest_commit_sha":null,"homepage":"","language":"Pascal","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"bsd-3-clause","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/tinyBigGAMES.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":".github/FUNDING.yml","license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null},"funding":{"github":"tinyBigGAMES","patreon":null,"open_collective":null,"ko_fi":null,"tidelift":null,"community_bridge":null,"liberapay":null,"issuehunt":null,"lfx_crowdfunding":null,"polar":null,"buy_me_a_coffee":null,"thanks_dev":null,"custom":null}},"created_at":"2025-06-26T05:25:46.000Z","updated_at":"2025-08-07T12:18:43.000Z","dependencies_parsed_at":"2025-06-26T06:30:59.278Z","dependency_job_id":"24139392-b0be-4357-8919-4cbfa689277a","html_url":"https://github.com/tinyBigGAMES/JetVM","commit_stats":null,"previous_names":["tinybiggames/jetvm"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/tinyBigGAMES/JetVM","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tinyBigGAMES%2FJetVM","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tinyBigGAMES%2FJetVM/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tinyBigGAMES%2FJetVM/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tinyBigGAMES%2FJetVM/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/tinyBigGAMES","download_url":"https://codeload.github.com/tinyBigGAMES/JetVM/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tinyBigGAMES%2FJetVM/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":270969225,"owners_count":24677278,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-08-18T02:00:08.743Z","response_time":89,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["bytecode","debugging","delphi","dsl","embedded","execution-engine","fluent-interface","high-performance","native-functions","object-pascal","pascal","runtime","scripting","stack-based","virtual-machine","win64","windows-11"],"created_at":"2025-06-27T00:12:40.322Z","updated_at":"2025-08-18T09:13:48.004Z","avatar_url":"https://github.com/tinyBigGAMES.png","language":"Pascal","funding_links":["https://github.com/sponsors/tinyBigGAMES"],"categories":[],"sub_categories":[],"readme":"![JetVM](media/jetvm.jpg)  \n[![Chat on Discord](https://img.shields.io/discord/754884471324672040?style=for-the-badge)](https://discord.gg/tPWjMwK)\n[![Follow on Bluesky](https://img.shields.io/badge/Bluesky-tinyBigGAMES-blue?style=for-the-badge\u0026logo=bluesky)](https://bsky.app/profile/tinybiggames.com)\n\n\u003e 🚧 **This repository is currently under construction.**\n\u003e\n\u003e JetVM is actively being developed and rapidly evolving. Some features mentioned in this documentation may not yet be fully implemented, and both APIs and internal structure are subject to change as we continue to improve and expand the library.\n\u003e\n\u003e Your contributions, feedback, and issue reports are highly valued and will help shape JetVM into the ultimate Pascal development platform!\n\n\n# 🚀 JetVM - Fast Delphi Virtual Machine\nJetVM is a A high-performance, stack-based virtual machine with native Delphi integration. It bridges the gap between performance and safety. Execute bytecode with configurable validation levels, from maximum speed to fully bounds-checked safe execution.\n\n## ✨ Features\n\n### 🎯 **Native Delphi Integration**\n- Uses native Delphi strings and memory management\n- Seamless integration with existing Delphi functions\n- Call native Delphi procedures directly from VM code\n- Zero external dependencies\n\n### ⚡ **Performance-Focused**\n- Cache-friendly data layout for hot execution paths\n- Multiple validation levels for speed vs safety tradeoffs\n- Optimized execution core with selective bounds checking\n- Tagged union design for maximum type performance\n\n### 🛡️ **Configurable Safety**\n```pascal\n// Choose your safety level:\nTJetVMValidationLevel = (\n  vlNone,        // Maximum speed - no checks\n  vlBasic,       // Emit-time validation only  \n  vlDevelopment, // Stack tracking, type hints\n  vlSafe         // Full runtime bounds checking\n);\n```\n\n### 🔧 **Modern Fluent API**\n```pascal\n// Beautiful, chainable bytecode generation\nVM := TJetVM.Create(vlDevelopment);\ntry\n  VM.LoadInt(42)\n    .LoadInt(100)\n    .AddInt()\n    .StoreLocal(0)\n    .CallFunction('PrintResult')\n    .Stop()\n    .Execute();\nfinally\n  VM.Free;\nend;\n```\n\n### 🎨 **Rich Type System**\n- **Integers**: Int64 \u0026 UInt64 with full arithmetic\n- **Strings**: Native Delphi string operations (Concat, Length, Copy, Pos, etc.)\n- **Booleans**: Logical operations and flow control\n- **Pointers**: Type-safe pointer operations with bounds checking\n- **Arrays**: Dynamic and fixed arrays with element access\n\n### 📊 **Comprehensive Bytecode Support**\n- **140+ optimized opcodes** covering all core operations\n- **Fluent assembly interface** for readable code generation\n- **Compile-time validation** with detailed error reporting\n- **Label management** with forward reference resolution\n\n## 🎯 Use Cases\n\nJetVM excels in scenarios requiring **safe execution** of **untrusted code**:\n\n- **🎮 Game Scripting**: Player mods, AI behaviors, quest systems  \n- **📊 Data Processing**: User-defined calculations, transformations, filters\n- **🔌 Plugin Systems**: Safe execution of third-party plugins and extensions\n- **📈 Calculators**: Advanced calculation engines with custom functions\n\n## 📈 Project Status\n\n### 🚀 **Current State**\n- **Core Infrastructure**: ✅ Production Ready (100% test coverage)\n- **Value System**: ✅ Fully Implemented (comprehensive test coverage)\n- **Stack Operations**: ✅ Complete \u0026 Validated (comprehensive test coverage)\n- **Constants Pool**: ✅ Complete \u0026 Tested (comprehensive test coverage)\n- **Bytecode Generation**: ✅ Complete \u0026 Fluent (comprehensive test coverage)\n\n### 🎯 **Development Roadmap**\n- **Q1 2025**: Complete core test suite ✅ **COMPLETE**\n- **Q2 2025**: Advanced opcode implementation \u0026 optimization\n- **Q3 2025**: Performance benchmarking \u0026 real-world integration examples\n- **Q4 2025**: Plugin architecture \u0026 ecosystem development tools\n\n### ⚡ **Performance Benchmarks**\nBased on current test results:\n- **VM Creation**: Sub-millisecond startup time\n- **Value Operations**: Microsecond-level execution  \n- **Bulk Processing**: 10,000+ operations in \u003c5000ms\n- **Memory Management**: Zero leak indicators in stress tests\n- **Test Execution**: 0.0003s average per test (1,093 tests in 0.371s)\n\n### 🏆 **Quality Metrics**\n- **Zero Defects**: No bugs detected in tested components\n- **100% Pass Rate**: All 1,093 tests consistently passing\n- **Enterprise Ready**: Robust error handling and edge case management\n- **Memory Safe**: Comprehensive bounds checking and leak prevention\n\n*See [TEST-REPORT.md](TEST-REPORT.md) for detailed performance analysis and quality metrics.*\n\n## 🚀 Quick Start\n\n### Basic Usage\n\n```pascal\nuses\n  JetVM;\n\nvar\n  LVM: TJetVM;\n  LResult: TJetValue;\nbegin\n  LVM := TJetVM.Create(vlBasic);\n  try\n    // Simple arithmetic: 10 + 32 = 42\n    LVM.LoadInt(10)\n       .LoadInt(32)\n       .AddInt()\n       .Stop();\n       \n    LVM.Execute();\n    \n    // Get result from stack\n    LResult := LVM.PeekValue();\n    WriteLn('Result: ', LResult.IntValue); // Output: 42\n  finally\n    LVM.Free;\n  end;\nend;\n```\n\n### String Operations\n\n```pascal\n// String manipulation with native Delphi functions\nLVM.LoadStr('Hello, ')\n   .LoadStr('World!')\n   .ConcatStr()\n   .UpperStr()\n   .Stop();\n   \nLVM.Execute();\nLResult := LVM.PeekValue();\nWriteLn(LResult.StrValue); // Output: HELLO, WORLD!\n```\n\n### Native Function Integration\n\n```pascal\n// Register a native Delphi function\nprocedure MyPrintLine(const AVM: TJetVM);\nvar\n  LValue: TJetValue;\nbegin\n  LValue := AVM.PopValue();\n  WriteLn('VM Output: ', LValue.StrValue);\nend;\n\n// Register and use in VM code\nLVM.RegisterNativeFunction('println', @MyPrintLine, [jvtStr]);\n\nLVM.LoadStr('Hello from VM!')\n   .CallNative('println')\n   .Stop();\n   \nLVM.Execute(); // Output: VM Output: Hello from VM!\n```\n\n### Advanced: Conditional Logic\n\n```pascal\n// if (x \u003e 10) then result := x * 2 else result := x + 5\nLVM.LoadInt(15)        // Load x = 15\n   .Dup()              // Duplicate for comparison\n   .LoadInt(10)        // Load comparison value\n   .GreaterThanInt()   // x \u003e 10?\n   .JumpIfFalse('else_branch')\n   \n   // True branch: x * 2\n   .LoadInt(2)\n   .MultiplyInt()\n   .Jump('end')\n   \n   .Label('else_branch')\n   // False branch: x + 5  \n   .LoadInt(5)\n   .AddInt()\n   \n   .Label('end')\n   .Stop();\n\nLVM.Execute();\nLResult := LVM.PeekValue();\nWriteLn('Result: ', LResult.IntValue); // Output: 30\n```\n\n## 📖 Documentation\n\n### 📚 **Comprehensive Developer Guide**\n**[DEVELOPER-GUIDE.md](DEVELOPER-GUIDE.md)** contains **12 detailed sections**:\n\n| Section | Content | Pages |\n|---------|---------|-------|\n| 🏗️ **Architecture** | Project overview, core features, performance characteristics | 📄📄 |\n| 💎 **Value System** | TJetValue tagged union, memory layout, type safety | 📄📄📄 |\n| 🛡️ **Validation Levels** | Performance vs safety, level switching, benchmarks | 📄📄 |\n| ⛓️ **Fluent Interface** | Bytecode generation, method chaining, complex expressions | 📄📄📄 |\n| 🎯 **Execution Model** | Stack machine, state management, control flow | 📄📄📄 |\n| 📞 **Function System** | Native integration, VM functions, parameter modes | 📄📄📄 |\n| 🧠 **Memory Management** | Automatic cleanup, bounds checking, debugging utilities | 📄📄 |\n| 🎪 **Practical Examples** | Calculator engines, game scripting, data processing | 📄📄📄📄 |\n| ⚡ **Performance Guide** | Optimization strategies, validation selection, benchmarking | 📄📄 |\n| ✅ **Best Practices** | Recommended patterns, anti-patterns, testing strategies | 📄📄📄 |\n| 🐛 **Error Handling** | Debugging utilities, exception strategies, validation | 📄📄 |\n| 🔌 **Integration** | Application integration, plugin architecture, web services | 📄📄📄 |\n\n### 📊 **Current Test Coverage Report**\n**[TEST-REPORT.md](TEST-REPORT.md)** provides comprehensive analysis:\n\n#### ✅ **Test Results Summary**\n- **1,093 tests executed** with **100% pass rate**\n- **0.371 seconds total execution time** (0.0003s average per test)\n- **Zero defects** detected in core functionality\n- **Enterprise-grade stability** demonstrated\n\n#### 📋 **Component Coverage Matrix**\n| Component | Coverage | Status | Test Count |\n|-----------|----------|--------|------------|\n| **Core VM \u0026 Execution** | 100% | ✅ Complete | 89 tests |\n| **Memory \u0026 Storage** | 100% | ✅ Complete | 260 tests |\n| **Control Flow** | 100% | ✅ Complete | 233 tests |\n| **Operations** | 100% | ✅ Complete | 182 tests |\n| **Data Types** | 100% | ✅ Complete | 169 tests |\n| **Infrastructure** | 100% | ✅ Complete | 54 tests |\n\n#### 🎯 **Test Distribution by Category**\n- **Memory \u0026 Storage**: 260 tests (23.8%) - Stack, Registers, Memory, Pointers, Arrays\n- **Control Flow**: 233 tests (21.3%) - Control Flow, Labels, Functions, Parameters  \n- **Operations**: 182 tests (16.7%) - Arithmetic, Bitwise, Comparisons, Strings\n- **Data Types**: 169 tests (15.5%) - Values, Type Conversion, Constants\n- **Core VM**: 142 tests (13.0%) - Core, Execution, Validation\n- **Infrastructure**: 54 tests (4.9%) - Bytecode Generation\n\n#### ⚡ **Performance Metrics**\n- **VM Creation**: Sub-millisecond startup\n- **Value Operations**: Microsecond-level execution\n- **Bulk Operations**: 10,000+ in \u003c5000ms\n- **Memory Safety**: Zero leak indicators\n\n### 🔧 **API Reference**\n- **Inline Documentation**: Comprehensive comments in `JetVM.pas`\n- **Interface Definitions**: All public methods documented\n- **Usage Examples**: Code samples for every major feature\n\n## 🧪 Testing \u0026 Quality Assurance\n\nJetVM maintains **enterprise-grade quality** through comprehensive testing:\n\n### ✅ **Current Test Status**\n- **1,093 tests** with **100% pass rate** _(Perfect success rate!)_\n- **0.371 seconds execution time** - enables rapid development cycles\n- **Zero defects** detected in core functionality\n- **Lightning performance** - 0.0003s average per test\n\n### 📋 **Test Coverage Breakdown**\n| Component | Tests | Coverage | Status |\n|-----------|-------|----------|--------|\n| **Arithmetic Operations** | 44 | 100% | ✅ Production Ready |\n| **Array Management** | 61 | 100% | ✅ All Operations Covered |\n| **Bitwise Operations** | 42 | 100% | ✅ Complete Implementation |\n| **Bytecode Generation** | 54 | 100% | ✅ Fluent Interface Ready |\n| **Comparison Operations** | 46 | 100% | ✅ All Types Validated |\n| **Constants Pool** | 50 | 100% | ✅ Complete Management |\n| **Control Flow** | 79 | 100% | ✅ All Patterns Tested |\n| **VM Core \u0026 Lifecycle** | 43 | 100% | ✅ Production Ready |\n| **Execution Engine** | 46 | 100% | ✅ Robust Operation |\n| **Function System** | 69 | 100% | ✅ Native Integration |\n| **Label Management** | 37 | 100% | ✅ Forward References |\n| **Memory Management** | 31 | 100% | ✅ Leak Prevention |\n| **Parameter Handling** | 48 | 100% | ✅ All Modes Tested |\n| **Pointer Operations** | 72 | 100% | ✅ Memory Safety |\n| **Register System** | 48 | 100% | ✅ Complete Access |\n| **Stack Operations** | 48 | 100% | ✅ Fully Validated |\n| **String Operations** | 50 | 100% | ✅ Unicode Support |\n| **Type Conversion** | 69 | 100% | ✅ Safe Casting |\n| **Validation System** | 53 | 100% | ✅ Error Prevention |\n| **Value System** | 50 | 100% | ✅ All Types Covered |\n\n### 🎯 **Quality Indicators**\n- **Coverage Depth**: Comprehensive edge case testing including boundary values\n- **Assertion Quality**: Meaningful validation criteria with specific expected results\n- **Error Scenarios**: Proper exception testing and graceful failure handling\n- **Performance**: Baseline characteristics established for regression detection\n\n### 🚀 **Test Phases Progress**\n```\nPhase 1: Core Infrastructure    ✅ 1,093 tests (100% pass)\nPhase 2: Advanced Features      ⏳ Planned Q2 2025\nPhase 3: Integration Testing    ⏳ Planned Q2 2025\nPhase 4: Performance Benchmarks ⏳ Planned Q2 2025\n```\n\n### 📊 **Test Execution**\nRun the comprehensive test suite:\n```bash\n# Execute all tests with custom logger\nJetVMTests.exe\n\n# Example output:\n# ================================================================================\n#                            🚀 JETVM TEST SUITE                            \n# ================================================================================\n# 📦 JetVM.Test.Core.TTestJetVMCore\n# ✓ TestVMCreationDefault\n# ✓ TestVMCreationWithValidationLevels\n# ✓ TestBasicExecution\n# [... 1,093 total tests across 20 fixtures ...]\n# ================================================================================\n#                            ✅ ALL TESTS PASSED\n# ================================================================================\n# Tests Found: 1,093 | Tests Passed: 1,093 | Duration: 0.371s\n```\n\n**See [TEST-REPORT.md](TEST-REPORT.md) for detailed analysis and performance metrics.**\n\n## 📦 Installation\n\n### Prerequisites\n- **Delphi XE2** or later (requires modern generics, Unicode, and 64-bit support)\n- **Tested with**: Delphi 12 on Windows 11 (24H2)\n- **Platform Support**: Windows (tested and supported)\n- **Dependencies**: None (pure Delphi implementation)\n\n### Setup\n1. **Clone the repository:**\n   ```bash\n   git clone https://github.com/tinyBigGAMES/JetVM.git\n   cd JetVM\n   ```\n\n2. **Add to your Delphi project:**\n   - Add `JetVM.pas` to your project\n   - Include `JetVM.Defines.inc` in your project path\n   - Add `JetVM` to your uses clause\n\n3. **Optional: Include test framework:**\n   ```pascal\n   // For comprehensive testing (optional)\n   uses\n     JetVM.Test.Core,\n     JetVM.Test.Values,\n     JetVM.Test.Logger;  // Custom DUnitX logger\n   ```\n\n4. **Verify installation:**\n   ```pascal\n   // Quick verification\n   var LVM := TJetVM.Create(vlBasic);\n   try\n     LVM.LoadInt(42).Stop().Execute();\n     Assert(LVM.PopValue().IntValue = 42);\n   finally\n     LVM.Free;\n   end;\n   ```\n\n## 📚 Documentation Overview\n\n### Core Classes \u0026 Interfaces\n\n#### **`TJetVM`** - Main Virtual Machine\n```pascal\n// Essential Methods\nprocedure Execute();              // Run the VM\nprocedure Step();                 // Single-step execution\nprocedure Reset();                // Reset VM state\nprocedure Finalize();             // Finalize bytecode\n\n// State Access\nfunction GetPC(): Integer;        // Program Counter\nfunction GetSP(): Integer;        // Stack Pointer\nfunction IsRunning(): Boolean;    // Execution state\n\n// Stack Operations\nprocedure PushValue(const AValue: TJetValue);\nfunction PopValue(): TJetValue;\nfunction PeekValue(const AOffset: Integer = 0): TJetValue;\n```\n\n#### **`TJetValue`** - Tagged Union Type System\n```pascal\n// Value Types\nTJetValueType = (jvtInt, jvtUInt, jvtStr, jvtBool, jvtPointer, \n                jvtArrayInt, jvtArrayUInt, jvtArrayStr, jvtArrayBool);\n\n// Factory Methods\nfunction MakeIntConstant(const AValue: Int64): TJetValue;\nfunction MakeStrConstant(const AValue: string): TJetValue;\n// ... additional factory methods\n```\n\n#### **`TJetFunctionRegistry`** - Function Management\n```pascal\n// Function Registration\nfunction RegisterNativeFunction(const AName: string; \n  const AProc: TJetNativeFunction; \n  const AParamTypes: array of TJetValueType;\n  const AReturnType: TJetValueType): Integer;\n```\n\n### Instruction Set Categories\n\n| Category | Instructions | Description | Examples |\n|----------|-------------|-------------|----------|\n| **Load/Store** | `LoadInt`, `LoadStr`, `StoreLocal`, `StoreGlobal` | Data movement | Variable access |\n| **Arithmetic** | `AddInt`, `SubInt`, `MulInt`, `DivInt`, `ModInt` | Math operations | Calculations |\n| **Comparison** | `EqInt`, `LtInt`, `GtInt`, `EqStr`, `LtStr` | Value comparisons | Conditionals |\n| **Control Flow** | `Jump`, `JumpTrue`, `JumpFalse`, `Call`, `Return` | Program flow | Loops, functions |\n| **String Ops** | `ConcatStr`, `LenStr`, `UpperStr`, `LowerStr` | String manipulation | Text processing |\n| **Memory** | `Alloc`, `FreeMem`, `MemCopy`, `LoadPtrInt` | Memory management | Pointer operations |\n| **Arrays** | `ArrayGet`, `ArraySet`, `ArrayLength` | Array operations | Data structures |\n| **Functions** | `CallFunction`, `RegisterNativeFunction` | Function calls | Native integration |\n\n## 🤝 Contributing\n\nWe welcome contributions! Our codebase maintains **100% test coverage** and **enterprise-grade quality**.\n\n### 🚀 **Quick Contribution Guide**\n\n1. **Fork \u0026 Clone**\n   ```bash\n   git clone https://github.com/YOUR_USERNAME/JetVM.git\n   cd JetVM\n   ```\n\n2. **Follow Our Standards** _(See [DEVELOPER-GUIDE.md](DEVELOPER-GUIDE.md) Section 10)_\n   ```pascal\n   // Delphi Conventions (CRITICAL)\n   var\n     LValue: TJetValue;     // Local variables start with 'L'\n     LResult: Integer;      // Each variable on separate line\n   \n   procedure MyProc(const AParam: string);  // Parameters start with 'A'\n   ```\n\n3. **Add Comprehensive Tests**\n   ```pascal\n   // Follow existing test patterns\n   [Test]\n   procedure TestYourNewFeature();\n   begin\n     Assert.AreEqual(Expected, Actual, 'Meaningful error message');\n   end;\n   ```\n\n4. **Ensure Quality**\n   ```bash\n   # All tests must pass\n   JetVMTests.exe\n   # Expected: 100% pass rate maintained\n   ```\n\n### 📋 **Coding Standards**\n- **Naming**: `L` prefix for locals, `A` prefix for parameters\n- **Declarations**: Each variable on separate line, no inline `var`\n- **Parameters**: Always `const` unless `var`/`out` needed\n- **Testing**: Comprehensive tests for all new functionality\n- **Documentation**: Update relevant guides and inline docs\n\n### 🎯 **Contribution Areas**\n- 🔧 **Core Features**: New opcodes, optimization improvements\n- 📚 **Documentation**: Examples, tutorials, API documentation\n- 🧪 **Testing**: Additional test cases, performance benchmarks\n- 🎨 **Tooling**: Development utilities, debugging aids\n- 🌍 **Examples**: Real-world usage demonstrations\n\n### 🌍 **Platform Testing Needed**\n- 🪟 **Windows**: ✅ Fully supported and tested\n- 🐧 **Linux**: ❓ Community testing welcome  \n- 🍎 **macOS**: ❓ Community testing welcome\n\n*Help us expand platform support by testing JetVM on Linux/macOS and reporting results! Since JetVM uses pure Delphi code, it may work on other platforms but needs validation.*\n\n### 🏆 **Contributors**\n\n\u003ca href=\"https://github.com/tinyBigGAMES/JetVM/graphs/contributors\"\u003e\n  \u003cimg src=\"https://contrib.rocks/image?repo=tinyBigGAMES/JetVM\u0026max=500\u0026columns=20\u0026anon=1\" /\u003e\n\u003c/a\u003e\n\n*Join our growing community of developers building the future of Delphi scripting!*\n\n## 📄 License\n\nThis project is licensed under the **BSD 3-Clause License** - see the [LICENSE](LICENSE) file for details.\n\n```\nBSD 3-Clause License\n\nCopyright © 2025-present tinyBigGAMES™ LLC\nAll Rights Reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice\n2. Redistributions in binary form must reproduce the above copyright notice\n3. Neither the name of the copyright holder nor the names of its contributors\n   may be used to endorse or promote products derived from this software\n   without specific prior written permission.\n```\n\n## 📞 Support \u0026 Community\n\n### 📚 **Documentation \u0026 Resources**\n- 📖 **[DEVELOPER-GUIDE.md](DEVELOPER-GUIDE.md)** - 12-section comprehensive development guide\n- 📊 **[TEST-REPORT.md](TEST-REPORT.md)** - Current test coverage \u0026 performance metrics\n- 🔧 **API Reference** - Inline documentation in `JetVM.pas`\n- 📋 **Examples** - Real-world usage patterns in test suites\n\n### 💬 **Community Channels**\n- 🐛 **Issues**: [GitHub Issues](https://github.com/tinyBigGAMES/JetVM/issues) - Bug reports \u0026 feature requests\n- 💬 **Discussions**: [GitHub Discussions](https://github.com/tinyBigGAMES/JetVM/discussions) - General questions \u0026 ideas\n- 💬 **Discord**: [Join our community](https://discord.gg/tPWjMwK) - Real-time chat \u0026 support\n- 🐦 **Bluesky**: [@tinybiggames.com](https://bsky.app/profile/tinybiggames.com) - Updates \u0026 announcements\n\n### ❓ **Frequently Asked Questions**\n\n**Q: What Delphi versions are supported?**  \nA: Delphi XE2 (2012) or later. Requires modern generics support and 64-bit compilation capabilities. Actively tested with Delphi 12 on Windows 11 (24H2).\n\n**Q: What platforms are supported?**  \nA: Currently Windows only (actively developed and tested). While JetVM uses pure Delphi code that may work on Linux/macOS, these platforms are untested and unsupported. Community testing and feedback for other platforms is welcome.\n\n**Q: How does performance compare to other VMs?**  \nA: Current benchmarks show sub-millisecond VM creation and microsecond-level value operations (0.0003s average per test). Comprehensive performance benchmarking is planned for Q2 2025. See [TEST-REPORT.md](TEST-REPORT.md) for current measured performance data.\n\n**Q: Is JetVM suitable for production use?**  \nA: Yes! Core infrastructure has 100% test coverage and zero detected defects.\n\n**Q: Can I integrate my existing Delphi functions?**  \nA: Absolutely! Native function integration is a core feature with simple registration.\n\n**Q: What's the memory overhead?**  \nA: Minimal. Uses native Delphi types and tagged unions for efficiency.\n\n## 🌟 Acknowledgments\n\n- 💖 **Built with love** for the Delphi community\n- 🎯 **Inspired by** modern VM design principles (V8, LuaJIT, .NET CLR)\n- 🚀 **Focused on** practical, real-world usage scenarios\n- 🏆 **Committed to** enterprise-grade quality and performance\n- 🌍 **Supporting** the future of Delphi application development\n\n### 🎖️ **Special Thanks**\n- **Delphi Community** - For continued support and feedback\n- **Beta Testers** - Early adopters who helped shape JetVM\n- **Contributors** - Everyone who has submitted issues, PRs, and improvements\n\n---\n\n**Made with ❤️ by [tinyBigGAMES™](https://github.com/tinyBigGAMES)**\n\n*Empowering Delphi developers with high-performance, safe scripting capabilities.* 🚀","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftinybiggames%2Fjetvm","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Ftinybiggames%2Fjetvm","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftinybiggames%2Fjetvm/lists"}