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 now has official Visual Studio Code tooling for .vyu source files.
🛒 Install Vayu from the VS Code Marketplace
⚡ 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 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 24 is now the current development phase: native floating-point support, math/runtime integration, and tensor migration.
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 CPython loading and expanded Python value/call interoperability
Phase 24 — Native floats
The next major backend/runtime milestone is native floating-point support. Vayu's native path is being extended from integer-centric execution to real float values, native arithmetic and comparisons, mixed integer/float operations, math-library coverage, float-aware collections, conversions, and migration of tensors away from Q16.16 storage.
Phase 23 — Single-binary native toolchain — Completed
Phase 23 established the transition from the QBE + GCC backend chain toward VCB as the dedicated native backend project. VCB is now treated as a separate sister project with its own repository and roadmap.
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–17 | Core language, runtime, native compilation, self-hosting preparation, ownership, FFI and CPython interoperability. Completed development phases. |
| 18 | LSP, formatter, linter, VS Code extension and compiler/runtime tooling. Completed. |
| 19 | Native window, event, canvas and widget layer. Completed. |
| 20 | 2D graphics, canvas drawing, text, transforms and image/UI primitives. Completed foundation. |
| 21 | Software raster and 3D pipeline: framebuffers, depth, matrices, meshes, textures, mipmaps, lighting and post-processing. Completed. |
| 22 | Package ecosystem and continued native/UI performance work. Completed development phase. |
| 23 | Single-binary native toolchain / VCB direction. Retire the QBE + GCC backend chain and establish VCB as the separate native backend project. Completed phase direction. |
| 24 | Native floats — 24.0 float type + ABI; 24.1 math + collections; 24.2 tensor migration. Current. |
| 25 | Benchmarking Round 1 (pre-VCB) — dedicated harness, control programs, compute-heavy and allocation-heavy workloads. |
| 26 | Version cut 1 — cross-platform toolchain builds, SDL3, VS Community LSP, Marketplace/Open VSX publishing, Vayu rewrites of Python tools, documentation and release. |
| 27 | VCB — separate project — PE object emitter, direct codegen, linker/runtime merge, ELF/Mach-O and ARM64. |
| 28 | Benchmarking Round 2 (post-VCB) — same suite and comparison languages, with a VCB delta report. |
| 29 | Version cut 2 — VCB-era single-binary toolchain release; QBE/GCC retired from docs and packaging; target v1.0. |
| 30+ | Open / parking lot — shaders, escape analysis, multi-input ONNX, GPU tensors, optimizer/loss additions and other future work. |
24 Native floats
25 Benchmarking Round 1 <- pre-VCB data
26 Version cut 1 <- QBE-era Vayu release
---
27 VCB (separate project)
28 Benchmarking Round 2 <- VCB delta report
29 Version cut 2 <- single-binary Vayu release
---
30+ Parking lot (shaders, escape analysis, multi-input ONNX, ...)
The roadmap describes the intended development sequence. A phase may require additional stabilization or implementation work before it is production-ready.
For benchmark information and website updates, see the official Vayu website.
Vayu is not trying to simply become:
"Python but faster."
or:
"C++ with Python syntax."
The bigger goal is to create a unified language ecosystem where developers can move naturally between:
simple programs → applications → AI → games → systems → native software
without needing to completely change languages.
Vayu is an independent project, but AI tools played an important role during its development.
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.