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 · 🖼️ Icon Support · 🧭 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.
The Windows build flow is configured to embed assets/Vayu_logo.ico into the generated vayu.exe. The VS Code extension package includes light and dark .vyu language icons and declares them in its language contribution. Actual executable generation remains dependent on the VIB native compiler being implemented; the current native compiler reports that this path is not ready. See Icon Support for asset paths, build behavior, theme handling, and Visual Studio limitations.
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
- Vayu-native APIs and runtime
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 is building VIB (Vayu Integration Backend), the integrated toolchain implementing the Integrator architecture. The first goal is a small, verified language subset that can be packaged as .vye (Vayu Executable) and run through a compatible Vayu/Integrator runtime. Broader language coverage, native code generation, caching, and incremental compilation come later. VIB is not a separate required executable.
flowchart TD
S[".vyu Source"] --> F["Vayu Frontend"]
F --> A["AST + Semantic Analysis"]
A --> I["Small Verified Integrator Representation (planned)"]
I --> P[".vye Package Writer (planned)"]
P --> E[".vye Vayu Executable"]
E --> R["Compatible Vayu / Integrator Runtime (planned)"]
→ VIB Architecture · → Complete VIB Technical Documentation · → Full Roadmap
Status: the initial Integrator,
.vyeformat, and package execution path are planned work, not yet complete. Use the currently supported interpreter/VM paths until the new pipeline has passing tests.
The Windows development layout contains Vayu-source utilities. No bundled DLL directory, LLD executable, import-library bundle, or external compiler backend is required.
| Path | Purpose |
|---|---|
tools/nva.vyu |
Vayu-source package manager |
tools/nva-server.vyu |
Reference read-only NVA registry server |
The first Integrator milestone targets the .vye runtime package, not native OS executables. Native compilation is later work and must not add a bundled linker/backend dependency. See Third-party software and files for the current dependency boundary.
For the file-by-file layout, build expectations, and local verification commands, see tools/README.md.
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
- Vayu-native AI/ML APIs as they are implemented
Vayu will expose AI/ML capabilities through native Vayu APIs as those features are implemented. ONNX support is deferred until after the Integrator core is stable; the plan is to build a Vayu-owned reader/runtime and native test fixtures. Libraries from foreign-language ecosystems are not automatically supported.
→ 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 its own programming language with .vyu source files, its own frontend, semantics, runtime, and compiler toolchain. Python-inspired syntax is a design influence only. Vayu does not currently provide Python, Java, .NET, or other foreign-language source/runtime compatibility. Native system-library interfaces, where explicitly implemented, are low-level platform interfaces and do not make those languages supported by Vayu.
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 |
Roadmap.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
- Vayu-native runtime and library development
- 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 goal is to make Vayu useful for small programs, applications, games, AI systems, and native software through Vayu-native language and library support.
Vayu has an expanding language frontend, interpreter, bytecode compiler/VM, runtime integrations, package tooling, and editor tooling. The compiler/runtime is transitioning to VIB (Vayu Integration Backend), which implements the Integrator architecture inside this repository. The first priority is a small, verified subset and the planned .vye Vayu Executable package, which requires a compatible Vayu/Integrator runtime.
The first Integrator and .vye implementation is still roadmap work until its format, execution path, and tests are present. Do not assume native code generation or .vye support is complete. Use the currently supported interpreter/VM paths.
Current language and runtime features remain subject to execution-mode coverage. Native support must be re-established feature-by-feature through the shared conformance suite rather than inferred from interpreter support.
Engineering roadmap: Roadmap.md
VIB architecture: docs/vib.md
VIB implementation: VIB/README.md
Benchmark predictions: VIB/docs/BENCHMARK_PREDICTIONS.md
The roadmap maps the historical language/tooling phases to the new VIB implementation phases. Performance expectations, including comparisons with JIT compilers, are hypotheses until measured reproducibly.
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 a readable syntax, native execution, and low-level control could be combined in one purpose-built 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.