What is Vix Language?

Overview

Vix is a lightweight, statically typed, and compiled programming language designed to provide near-native C++ execution speed while maintaining the simplicity and ease of use found in scripting languages. It combines features of functional and object-oriented programming, supports multiple compilation backends, and boasts a clean syntax alongside a powerful type system.

Core Features

🚀 High Performance

Code generated by Vix executes at speeds close to native C++. Through LLVM backend optimizations, Vix programs can fully leverage the performance advantages of modern processors.

🌐 Cross-platform + Multi-architecture

• Operating Systems: Windows, Linux, macOS
• Processor Architectures: x86, ARM, RISC-V

📝 Concise Syntax

Vix's syntax is designed with a focus on conciseness and readability:

fn fib(n: i32) -> i32 {
    if (n <= 1) {
        return n
    }
    return fib(n-1) + fib(n-2)
}

fn main() -> i32 {
    print(fib(10))
}

🔒 Static Type System

Vix employs a static type system that catches type errors at compile time, enhancing code reliability and maintainability:

let a: i32 = 10
let b: f64 = 3.14
let c: string = "Hello"

🎯 Multi-backend Support

Vix supports several compilation backends (Note: Planning to consolidate to LLVM only):

Backend	Status	Description
LLVM	✅ Primary Backend	Most feature-complete with the strongest optimization capabilities.
QBE	🔄 Planned Removal	Lightweight backend for fast compilation.
C++	🔄 Planned Removal	Indirect compilation through generated C++ code.

🧩 Bootstrapping Progress

Vix is in the process of bootstrapping (writing the Vix compiler in Vix itself), with current progress around 90%. Bootstrapping is a significant milestone in the maturity of a programming language.

Design Philosophy

1. Simplicity First

Vix believes that code should be clear and easy to read. Reducing unnecessary syntactic noise allows developers to focus on solving the problem at hand.

2. Performance Above All

As a compiled language, Vix strives for performance close to C/C++. It generates efficient machine code via LLVM's optimization power.

3. Safety

Features like static type checking and null pointer handling help developers discover potential issues during the compilation phase.

4. Pragmatism

Vix does not chase after purely functional or object-oriented paradigms. Instead, it blends the advantages of multiple programming paradigms based on practical needs.

Use Cases

Systems Programming

Vix is suitable for writing system-level programs:

• Operating system components
• Drivers
• Embedded systems

Command Line Tools

The concise syntax makes Vix ideal for writing CLI tools:

• File processing utilities
• Automation scripts
• Build tools

Performance-Sensitive Applications

When you need performance close to C but want a more modern syntax:

• Data processing
• Scientific computing
• Games/Graphics applications

Teaching and Learning

Vix's clear syntax makes it an excellent choice for learning programming:

• Understanding compiler principles
• Learning systems programming concepts
• Exploring language design

Comparison with Other Languages

Vix vs C

Feature	Vix	C
Memory Safety	Safer pointer operations	Manual management
Syntax	Modern, concise	Traditional, verbose
Generics	Supported	Via macros
Compilation Speed	Relatively fast	Fast

Vix vs Rust

Feature	Vix	Rust
Learning Curve	Shallow	Relatively steep
Borrow Checker	None	Yes
Runtime Overhead	Nearly zero	Nearly zero
Ecosystem	Developing	Mature

Vix vs Go

Feature	Vix	Go
Type System	Static	Static
Generics	Supported	Limited support
Concurrency	Planned	goroutines
Compilation Speed	Fast	Very fast

Bootstrapped Compiler: vixc0

Vix is implementing bootstrapping—writing the Vix compiler in Vix. vixc0 is the stage0 version of the bootstrapped compiler, written entirely in the Vix language.

Current Functionality

• Lexical Analysis (Lexer)
• Syntactic Analysis (Parser)
• Type Inference
• LLVM IR Code Generation

Usage

# Compile vixc0
vixc main.vix -o vixc0

# Use vixc0 to compile Vix code
./vixc0 --emit-ll input.vix output.ll
./vixc0 --debug input.vix  # Debug mode
./vixc0 --help             # Show help
./vixc0 --version          # Show version

Bootstrapping Process

1. Stage 0: vixc (written in C) compiles vixc0 (written in Vix).
2. Stage 1: vixc0 compiles itself.
3. Stage 2: Verify that Stage 0 and Stage 1 produce the same output.

Bootstrapping is a key indicator of a language's maturity, and Vix is rapidly advancing toward this goal.

---

Project Ecosystem

Vix is building a complete ecosystem:

Project	Description	Status
Vix Compiler (vixc)	Core compiler (written in C, LLVM backend)	In development
vixc0	Bootstrapped compiler (written in Vix)	Bootstrapping in progress
VPM	Vix Package Manager	Community contributions welcome
Standard Library	Common data structures and functions	Community contributions welcome
VS Code Extension	Editor support	Released

Roadmap

Short-term Goals

• [x] Basic architecture for bootstrapped compiler vixc0
• [ ] Complete bootstrapping (vixc0 can compile itself)
• [ ] Retain only the LLVM backend
• [ ] Refine the standard library
• [ ] Release a stable version

Mid-term Goals

• [ ] Package Manager (VPM)
• [ ] Concurrency support
• [ ] Support for more platforms

Long-term Vision

• [ ] Full IDE support
• [ ] Custom metaprogramming
• [ ] Interoperability with other languages

Bootstrapping Progress

Current bootstrapping progress is approximately 90%:

• [x] Lexer
• [x] Parser
• [x] Type Inference
• [x] LLVM IR Generation
• [ ] Full language feature support
• [ ] Self-compilation validation

Open Source License

Vix is open-sourced under the Apache License 2.0 - see the LICENSE file for details.

Connect with the Community

• Email: popolk1871@outlook.com
• GitHub Issues: Submit bugs or suggestions in the repository
• QQ Group: 130577506

---

If you are interested in Vix, feel free to star, fork, submit issues, or just give it a try!