A modern general-purpose programming language designed to combine simplicity, performance, portability, and powerful application development.
Vayu brings together Python-inspired readability, native-performance goals, low-level control, modern typing, AI/ML ambitions, and application-development capabilities in one language.
🌐 Official Website · 📖 Syntax · 🤖 AI & ML · 📦 Packages · 🧭 Roadmap · 📊 Benchmarks · 🧩 VS Code
Visit the official Vayu website →
The website is the primary place for the latest Vayu information, roadmap, syntax references, benchmark information, and project updates. The Vayu logo and the banner links at the top of this README are clickable and lead directly to the website.
Vayu includes benchmarking as part of its development and performance evaluation process. Benchmarks are used to track compiler/runtime progress and compare representative workloads as the implementation evolves.
→ View the Vayu website and current benchmark information
Benchmark numbers are implementation- and environment-dependent. The website should be treated as the current source for published benchmark results rather than treating README numbers as permanent guarantees.
Vayu has editor tooling for .vyu source files through the VS Code extension and a native Visual Studio Community TextMate/VSIX extension.
🛒 Install Vayu from the VS Code Marketplace
Visual Studio Community: build vscommunity-vayu-Extention with its build.ps1 script and install the generated vayu-lang-support-1.0.0.vsix.
⚡ Install directly in VS Code
The extension provides editor-side integration for Vayu, including:
.vyulanguage support- Syntax highlighting
- Vayu Language Server integration
- Diagnostics
- Hover information
- Go to definition
- Completion
- References
- Rename support
- Signature help
- Formatter integration
- Linter integration
- Vayu configuration support
The compiler repository also contains the standalone vls, vfmt, and vlint tooling used by the extension.
Vayu is a next-generation programming language designed to combine the best ideas from:
- 🐍 Python — simple, readable syntax and a powerful ecosystem
- ⚡ C++ — native performance and low-level control
- ☕ Java — portability and large-scale application development
- 🎯 C# — modern application and GUI development
Vayu aims to provide these capabilities without forcing developers to switch between multiple languages for different types of software.
Write simple. Run native. Control everything.
Vayu is built around a simple idea:
Programming should be easy to learn, powerful enough for professionals, and fast enough for demanding software.
The language focuses on:
- Clean, Python-inspired syntax
- Native compiled execution
- Strong static typing with type inference
- Optional explicit type annotations
- Modern memory and resource management
- High-level APIs with low-level access when required
- AI/ML and scientific computing
- GUI and application development
- Game and graphics development
- Systems and performance-oriented programming
- Cross-platform development
- C/C++ interoperability
- Python ecosystem interoperability
- Future Java and .NET interoperability
| Capability | Python | C++ | Java | C# | Vayu |
|---|---|---|---|---|---|
| Beginner-friendly syntax | ⭐⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Native performance | ⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Low-level control | ⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Type inference | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Memory control | ⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| AI/ML ecosystem | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| GUI/application development | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Game development | ⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Cross-platform | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Simplicity + performance | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
These ratings represent Vayu's design goals, not a claim that it currently has the maturity or ecosystem size of established languages.
Vayu uses a clean, indentation-friendly syntax designed to remain readable while supporting serious software development.
The complete syntax and currently implemented features are documented separately:
→ Read the Vayu Syntax Reference
Vayu is designed as a compiled native language.
The goal is to provide:
- Native machine-code execution
- Compiler optimizations
- Efficient memory usage
- Hardware-level control
- Low runtime overhead
- High-performance applications
Vayu owns the language frontend and lowers supported programs into VCBIR. VCB parses VCBIR, generates x86-64 machine code, emits the required runtime, and writes the final PE or ELF executable.
flowchart LR
S[".vyu Source"] --> F["Vayu Frontend"]
F --> L["VcbLower"]
L --> I["VCBIR"]
I --> V["VCB"]
V --> C["x86-64 Codegen + Runtime"]
C --> P["PE Writer"]
C --> E["ELF Writer"]
P --> W["Windows PE"]
E --> X["Linux ELF"]
Vayu combines:
- Static typing
- Type inference
- Optional type annotations
- Generic types
- Structs
- Classes
- Inheritance
- Function types
- Modern error handling
Vayu is designed to provide both convenience and control.
The language aims to support:
- Automatic management for common cases
- Deterministic resource handling
- Ownership-oriented programming
- Smart pointers
- Explicit memory operations
- Unsafe/low-level programming when required
Planned smart-pointer concepts include:
unique<T>
shared<T>
weak<T>
AI is a major direction of Vayu.
The ecosystem is planned to support:
- Machine learning
- Deep learning
- Neural networks
- Tensor operations
- Data processing
- Computer vision
- GPU acceleration
- CUDA
- ONNX
- Python AI ecosystem interoperability
Target compatibility includes technologies such as NumPy, PyTorch, TensorFlow, OpenCV, ONNX, CUDA, and ROCm.
→ Read the Vayu AI & ML Documentation
Vayu is designed around a dedicated package ecosystem.
The package manager is planned around:
nva install <package>
The ecosystem is intended to provide:
- Package installation
- Dependency management
- Version management
- Project configuration
- Lock files
- Package publishing
- Build integration
- Native libraries
- AI/ML packages
- GUI libraries
- Game-development libraries
The package documentation contains the detailed package-system specification:
→ Read the Vayu Package Documentation
Package-manager naming and implementation may evolve as the ecosystem matures.
Vayu is designed to cover more than command-line programs.
- Desktop applications
- Modern user interfaces
- Native application APIs
- Cross-platform GUI development
- Game logic
- Graphics
- Input
- Audio
- Physics
- Rendering
- OpenGL
- Vulkan
- DirectX
- Native applications
- System utilities
- Hardware-oriented software
- High-performance services
- Networking
- Numerical computing
- Data processing
- Scientific applications
- Visualization
- AI/ML workflows
Vayu is intended to work with existing ecosystems instead of isolating developers.
Native interoperability is a major part of Vayu's systems-programming direction, allowing existing native libraries and platform APIs to be used.
Vayu is designed to interact with the Python ecosystem through runtime/FFI interoperability where appropriate, especially for AI, ML, data science, and scientific computing.
Future interoperability is intended through JVM/JNI-based integration.
Future interoperability is intended through .NET integration.
Vayu is designed to become a cross-platform language.
Target platforms include:
- Windows
- Linux
- macOS
- Android
- Other platforms as the compiler and ecosystem mature
Vayu source files use:
.vyu
Examples:
hello.vyu
main.vyu
game.vyu
ai.vyu
The official language name is Vayu and the official source extension is .vyu.
| Document | Purpose |
|---|---|
docs/syntax.md |
Complete language syntax and implemented features |
docs/package.md |
Package manager and ecosystem |
docs/ai.md |
AI/ML direction and ecosystem |
docs/vision.md |
Long-term vision, phased roadmap, and current development status |
CODE OF CONDUCT.md |
Community standards and contributor conduct |
REPORTING_GUIDELINES.md |
Guidelines for reporting and handling unacceptable behavior |
Vayu is intended to grow into a complete development ecosystem.
The long-term vision includes:
- Mature native compiler
- Advanced optimizer
- Self-hosting compiler
- Standard library
- Package ecosystem
- IDE/LSP support
- VS Code extension, formatter and linter
- Debugging tools
- AI/ML stack
- GUI framework
- Game-development stack
- Graphics APIs
- Native interoperability
- Cross-platform tooling
- Modern concurrency
- Metaprogramming
- Professional developer tooling
Vayu is currently being developed by one independent developer.
There is:
- No company behind the project
- No corporate development team
- No revenue model
- No large development budget
- No large engineering organization
Vayu is being developed as an independent project driven by experimentation, learning, engineering, and the goal of creating a language that combines ideas from several ecosystems.
Small team. Big vision.
Contributions, ideas, bug reports, documentation improvements, and language-design discussions are welcome.
Before contributing, please read CODE OF CONDUCT.md and follow the project's community standards.
- Python-inspired readability
- Native compiled execution
- Low-level capabilities
- Static typing with inference
- Modern memory-management direction
- AI/ML-focused ecosystem
- GUI development goals
- Game-development goals
- Systems-programming capabilities
- Cross-platform ambitions
- C/C++ interoperability
- Python ecosystem interoperability
- Beginner-friendly philosophy
- Professional-development ambitions
- One unified ecosystem instead of many disconnected languages
Vayu is still an evolving language.
Important limitations include:
- Small ecosystem
- Limited third-party packages
- Young compiler
- Developing tooling
- IDE support is currently centered on Visual Studio Code
- Advanced IDE integrations and debugger tooling are still evolving
- Limited documentation compared with established languages
- Smaller community
- Many planned features are not yet mature
- Compatibility layers are still evolving
- Performance and stability will improve as the compiler matures
Vayu should therefore be considered an early-stage independent language project, not a replacement for mature languages yet.
Vayu is designed for developers who want to work across multiple areas without constantly changing languages.
Potential users include:
- Beginners learning programming
- Application developers
- Systems programmers
- Game developers
- AI/ML developers
- Scientific programmers
- Tool developers
- Desktop application developers
- Performance-oriented developers
- Developers coming from Python
- Developers coming from C++
- Developers interested in language design
Common tasks should require minimal unnecessary code.
High-level syntax should not automatically mean low performance.
Developers should be able to access lower-level capabilities when needed.
Existing ecosystems should be usable rather than discarded.
Software should be able to move across platforms with minimal changes.
Features should solve real development problems rather than exist only because they are technically possible.
The long-term goal is to make Vayu useful for everything from small programs and applications to games, AI systems, and native software.
Vayu is an early-stage independent programming language project with an expanding compiler, runtime, tooling, FFI layer, Python/CPython interoperability, and native-backend work.
Phase 23 has been completed. Phases 19 and 20 established the native window/event/widget and 2D graphics foundations; Phase 21 completed the software raster and 3D pipeline; Phase 22 established the package-ecosystem direction and continued runtime/UI work; Phase 23 completed the single-binary native-toolchain direction toward VCB. The C++ vayuc compiler remains the bootstrap/reference compiler while the project continues toward self-hosting.
Phase 27 Parts 1–10 and 12–16 are complete; Part 11 is partial, and Part 17 is the next backend milestone. Phase 25 is intentionally skipped for now. Phase 26 Part 1 and Part 2 are complete. VCB is the active native backend for Vayu, with Windows PE and Linux ELF output, runtime emission, executable-format handling, and target validation.
Current implemented areas include:
- indentation-based
.vyusyntax - static type checking and type inference
- functions, recursion, lambdas, closures and higher-order functions
- lists, maps, tuples and sets, including slicing
- structs, classes, inheritance, overriding and
super() - exceptions and modules
const,enum, static members and visibility modifiersmatch,with,defer,yieldand generators- bitwise operators and compound assignment
- ownership/reference types such as
unique<T>,shared<T>, andweak<T> - raw pointers, references, pointer arithmetic,
malloc()andfree() - C FFI, function pointers, external-library linking and supported struct-by-value FFI
- runtime modules including math, filesystem/OS, regex, threading, networking, crypto, random, time and JSON
- native floating-point values, mixed int/float arithmetic, comparisons and conversions
- native
math.*operations, float lists and float-valued maps - VCB-backed native compilation and executable emission
- native CPython loading and expanded Python value/call interoperability
Current development — VCB-backed native toolchain
Vayu's native compiler now lowers supported Vayu programs into VCB IR and uses VCB for native code generation and executable emission. Windows native output is backed by VCB's PE path, and the Linux path is covered by VCB's ELF target and the Phase 27 ELF matrix.
Phase 27 Parts 1–16 — Done
The completed work covers the ELF writer and Linux runtime subset, Linux heap/list/map/string runtime, PE correctness and padding, relocations and ASLR, .pdata / .xdata, kernel32 heap APIs, Linux vayu_print_float, PE layout corrections, WDAC diagnosis and signing tools, shared x86-64 emitter extraction, the 11-program PE matrix, runtime .pdata / .xdata coverage, and the Linux ELF matrix.
Phase 27 Parts 1–16 — Done.
Phase 27 Part 17 — Next: move import-table construction into writePe, remove the kIdataRva hardcode, and add Linux .eh_frame.
Phase 18 — Vayu developer tooling
The current development track focuses on making Vayu practical to use inside a modern editor and development workflow. The repository now contains the Vayu Language Server, formatter, linter, and VS Code extension, alongside the existing compiler/runtime infrastructure.
Phase 17 — Vayu self-hosting / compiler bootstrap
The existing C++ vayuc remains the bootstrap/reference compiler while Vayu itself is developed toward feature parity. The long-term objective is for Vayu to compile its own compiler and eventually allow the C++ bootstrap implementation to be dropped.
| Phase | Scope |
|---|---|
| 1–24 | Core language, runtime, tooling, graphics, package ecosystem, native floats and related compiler/runtime work. Completed. |
| 25 | Skipped for now — benchmarking postponed until after the VCB transition. |
| 26 Part 1 | Completed — VCB project, IR, parser, printer, and vcb dump. |
| 26 Part 2 | Completed — x86-64 code generation, PE + ELF writers, prebuilt runtime, and Vayu's native path transitioned from QBE+GCC to VCB. |
| 27 Part 1 | Done — ELF writer, Linux syscall runtime subset. |
| 27 Part 2 | Done — Linux heap using a brk-based bump allocator, list + map + string-method runtime support. |
| 27 Part 3 | Done — PE padding heuristic. |
| 27 Part 4 | Done — DYNAMIC_BASE disabled, dynamic sections, shadow space in vayu_exit. |
| 27 Part 5 | Done — Minimal .reloc support. |
| 27 Part 6 | Done — ASLR re-enabled; .pdata / .xdata for user functions and the entry stub. |
| 27 Part 7 | Done — kernel32 heap APIs. |
| 27 Part 8 | Done — Linux vayu_print_float. |
| 27 Part 9 | Done — Always emit .rdata, always pad, RELOCS_STRIPPED + ASLR off. |
| Diagnosis | Done — Block identified as inbox WDAC (VerifiedAndReputableDesktop). |
| 27 Part 10 | Done — vcb sign / vcb verify / vcb build --sign. |
| 27 Part 11 | Partial — WDAC supplemental policy requires -UserPEs and a Microsoft-trusted signer; full acceptance requires a CA-trusted certificate or a machine without the inbox policy. |
| 27 Part 12 | Done — Import-table construction stays in X64.cpp for now; runtime .pdata deferred to Part 15. |
| 27 Part 13 | Done — X64Common.hpp extracted; X64.cpp reduced to a thin wrapper. |
| 27 Part 14 | Done — PE test matrix covering 11 programs; t10 fixed. |
| 27 Part 15 | Done — Runtime .pdata via emitRuntime(..., &unwindEntries); .xdata built from all entries. |
| 27 Part 16 | Done — tests\\elf_matrix.ps1 added for Linux target coverage. |
| 27 Part 17 | Next — Move import-table construction into writePe; remove kIdataRva hardcode; add Linux .eh_frame. |
| 27 Part 17 | Next — Move import-table construction into writePe; remove kIdataRva hardcode; add Linux .eh_frame. |
| 28 | Full benchmarking on VCB-built binaries. |
| 29 | Version cut. |
| 30+ | Open — BigFloat, shaders, escape analysis 8.1–8.3, multi-input ONNX, GPU tensor, Adam/softmax. |
DeepSeek played the larger supporting role in the development process.
It provided substantial assistance with:
- Programming
- Compiler development
- Architecture discussions
- Debugging
- Language design
- Implementation planning
- Turning concepts into practical code
- Exploring solutions during development
Thank you, DeepSeek, for being a major part of the Vayu journey. ❤️
ChatGPT provided a smaller supporting role, mainly helping with:
- Confirmation
- Design discussions
- Brainstorming
- Documentation refinement
- Reviewing ideas
- Clarifying technical concepts
Thank you, ChatGPT, for being part of the Vayu journey. ❤️
Acknowledgement of these tools does not imply sponsorship, partnership, endorsement, or official affiliation with Vayu or its developer.
Vayu is an ambitious independent experiment:
What if the simplicity of Python, the performance and control of C++, the portability of Java, and the application-development strengths of C# could move toward one unified language?
Vayu is an attempt to explore that idea.
It is still young.
It is still evolving.
And there is a long way to go.
But the goal is simple:
Make programming simpler without giving up power.
Write simple. Run native. Control everything.
Made independently with ❤️, code, experimentation, and a lot of debugging.