wingetCollections
  • Auto
  • Search
  • Awesome Collections
  • Awesome Programs
  • My Favorite Collections
  • My Collections
  • Account / Settings
  • Terms of Service
  • Privacy
  • About
  • What is WinGet?

© 2026 winget.ragerworks.com

Loading...
  1. Go back
  2. Packages
  3. Fusion Programming Language
Fusion Programming Language logo

Fusion Programming Language QuantumSecure Technologies Inc

blockchain compiler fusion post-quantum programming-language quantum-computing systems-programming
Use this command to install Fusion Programming Language with WinGet:
winget install --id=QSTech.Fusion -e

Fusion v2.0 Vortex is a general-purpose, polyglot systems programming language designed for the post-quantum era. Features include algebraic effects, linear types, dependent types, refinement types, tail-call optimization, actors, pattern matching, post-quantum cryptography, quantum computing primitives, blockchain modules, and a multi-target compiler (LLVM/WASM/bytecode).

README

Fusion v2.0 Vortex

The Polyglot Programming Language

A modern, general-purpose, polyglot systems programming language with post-quantum cryptography, quantum computing, blockchain, and 16 advanced programming language theory features.

Installation • Quick Start • Features • Documentation • Examples • Contributing

Why Fusion?

Fusion is not just another programming language — it's a polyglot systems language built for the post-quantum era. It combines the safety of Rust, the expressiveness of Python, the performance of C++, and the interoperability of GraalVM, all while enforcing 50/50 hybrid post-quantum cryptography by default.

Key Differentiators

FeatureFusionRustPythonGo
Post-Quantum Crypto50/50 hybrid enforcedManualManualManual
Quantum ComputingBuilt-in simulator + 5 backendsNoQiskit (external)No
Blockchain31 modules built-inNoNoNo
Polyglot InteropNative FFI to C/Python/JS/Java/RustLimited FFIC extension onlycgo
16 Advanced PLT FeaturesEffects, Linear Types, TCO, Actors, etc.PartialNoNo
Type SystemStatic + Gradual + Refinement + DependentStatic onlyDynamicStatic only
Memory ModelOwnership + Linear Types + GCOwnership onlyGC onlyGC only

Installation

Quick Install (Recommended)

Windows

# PowerShell (Run as Administrator)
.\installers\windows\install.ps1

# Or using winget
winget install QuantumSecureTechnologiesInc.Fusion

Linux

# Ubuntu/Debian
sudo dpkg -i installers/linux/debian/fusion-lang.deb

# Fedora/RHEL
sudo rpm -i installers/linux/rpm/fusion-lang.rpm

# Universal
bash installers/linux/install.sh

macOS

# Homebrew
brew install fusion-lang

# Or using the installer
bash installers/macos/install.sh

Native Fusion Installer

# Requires a working Fusion compiler
fusion run installers/windows/install.fu   # Windows
fusion run installers/linux/install.fu     # Linux
fusion run installers/macos/install.fu     # macOS

From Source

git clone https://github.com/QuantumSecureTechnologiesInc/Fusion-Programming-Language.git
cd Fusion-Programming-Language
cargo build --release

Quick Start

Hello World

fn main() -> void {
    println("Hello, Fusion v2.0 Vortex!");
}

fusion init hello
cd hello
fusion run

Post-Quantum Crypto

fn main() -> void {
    let keypair = pqc_hybrid_keygen();
    let signature = pqc_hybrid_sign(keypair, "Hello, Quantum-Safe World!");
    let valid = pqc_hybrid_verify(keypair, "Hello, Quantum-Safe World!", signature);
    println("Signature valid: " + valid);
}

Quantum Computing

fn main() -> void {
    let circuit = quantum_circuit(2);
    circuit.h(0);
    circuit.cx(0, 1);
    let result = circuit.measure();
    println("Bell state: " + result);
}

Blockchain

fn main() -> void {
    let chain = chain_new(4);
    let tx = tx_new("alice", "bob", 100.0, 0.01);
    let block = pow_mine(block_new(chain_height(chain) + 1, block_hash(chain_latest(chain)), "tx"), pow_new(4));
    let updated = chain_add_block(chain, block_data(block));
    println("Chain length: " + chain_length(updated));
}

Features

Core Language (Pillar 1: The Soul)

Turing Complete

  • Sequential Execution — Statements run in order
  • Conditional Branching — if/else/match with pattern matching
  • Iteration — while, for-in, break, continue
  • Recursion — Full recursive function support with guaranteed TCO

Data Types

  • Primitives: int, float, bool, string, char, void
  • Composite: Arrays [T; N], Structs, Enums (unit/tuple/struct variants)
  • Collections: Vector, HashMap, HashSet, LinkedList
  • Variables: let (immutable), let mut (mutable), const (compile-time)

Operators

  • Arithmetic: +, -, *, /, %
  • Comparison: ==, !=, <, >, <=, >=
  • Logical: &&, ||, !
  • Bitwise: &, |, ^, <<, >>
  • Full precedence table with left-to-right associativity

Abstraction

  • Functions with typed parameters and return values
  • Methods via impl blocks
  • Closures with capture semantics
  • First-class functions
  • Traits for polymorphism

Execution Model (Pillar 2: The Engine)

Multi-Target Compilation

  • LLVM Backend — Native x86_64/ARM compilation
  • WASM Backend — WebAssembly for browser/edge
  • Bytecode VM — Stack-based interpreter
  • Full Pipeline: Lex → Parse → Sema → Borrow Check → Vortex → IR → SSA → Optimize → Codegen

Memory Management

  • Ownership System — Rust-style move semantics
  • Borrow Checker — Compile-time reference safety
  • Linear Types — Exact-once usage for resources
  • Vortex Safety Engine — Permission state machine
  • Garbage Collection — For polyglot objects

Concurrency

  • Threads — OS-level threading
  • Fibers — Green threads with cooperative scheduling
  • Async/Await — Non-blocking I/O
  • Channels — Message passing
  • Mutex/RwLock — Shared state synchronization
  • Atomics — Lock-free operations
  • Supernova Runtime — CPU/GPU/QPU dispatch
  • Cortex Scheduler — AI-powered workload routing

Safety & Error Handling (Pillar 3: The Airbags)

Type System

  • Static Typing with full inference
  • Gradual Typing — Mix static and dynamic
  • Refinement Types — {x: Int | x > 0}
  • Dependent Types — Types depending on values
  • Linear Types — Resource protocol enforcement

Error Handling

  • Result — Recoverable errors with pattern matching
  • Option — Null safety without null pointers
  • panic/abort — Unrecoverable errors
  • RAII — Deterministic resource cleanup
  • try/catch — Exception-like patterns
  • Assert macros — Runtime verification

Advanced PLT Features (16 Total)

FeatureDescription Algebraic EffectsSide-effect tracking with handlers Linear TypesResource protocol enforcement Dependent TypesTypes depending on values Refinement TypesLogical predicates on types Gradual TypingStatic + dynamic hybrid Guaranteed TCOTail-call optimization ContinuationsFirst-class control flow Capability SecurityObject-capability model Multiple DispatchMethod resolution by all args Effect PolymorphismGeneric effect signatures Formal VerificationCompile-time proof hooks Partial EvaluationMulti-stage programming Actor ModelBuilt-in actors + supervision Custom AllocatorsPer-type memory allocation Unsafe ProvenanceProof requirements for unsafe Blockchain31 built-in modules

Blockchain Development (31 Modules)

Core & Consensus

  • Blocks, Chains, Transactions, Merkle Trees
  • Proof of Work (PoW) with difficulty adjustment
  • Proof of Stake (PoS) with weighted selection
  • Delegated Proof of Stake (DPoS) with voting
  • PBFT three-phase consensus

Tokens & Contracts

  • ERC-20 Fungible Tokens
  • ERC-721 NFTs
  • ERC-1155 Multi-Token
  • Smart Contracts (deploy, call, upgrade)
  • Custom Token Standards

DeFi & Privacy

  • AMM Liquidity Pools (x*y=k)
  • Lending/Borrowing
  • Stealth Addresses
  • Confidential Transactions
  • Shielded Pools
  • Zero-Knowledge Proofs

Governance & Infrastructure

  • On-chain Proposals & Voting
  • DAOs with Treasury
  • Staking & Rewards
  • Cross-chain Bridges
  • Layer 2 (State Channels, Rollups)
  • Oracles

Polyglot Interoperability (Pillar 5: Social Skills)

Language Bridges

  • Python — Full FFI with type marshaling
  • JavaScript — V8/QuickJS integration
  • Java — JNI-style interface
  • Rust — C FFI bridge with type mapping
  • C/C++ — Direct C ABI calls

Interop Features

  • Polyglot API — import, export, eval across languages
  • Shared Memory — Zero-copy cross-language data transfer
  • Foreign Proxies — Transparent access to foreign objects
  • Type Mapping — Automatic conversion between languages
  • Cross-Language Concurrency — Thread pools and async bridges

Standard Library

Core Modules

  • I/O — println, print, read_line, read_int
  • Filesystem — Read, write, append, exists, mkdir, rm
  • Strings — Length, compare, contains, trim, replace, split
  • Math — sqrt, sin, cos, pow, log, exp, random, constants
  • Collections — Vector, HashMap, HashSet, LinkedList
  • Error Handling — Result, Option, assert, panic, abort
  • JSON — Serialize/deserialize
  • HTTP — Request/response
  • Networking — TCP/UDP

Toolchain (Pillar 6: Assembly Line)

ToolCommandDescription CompilerfucFull compilation pipeline CLIfusion17+ commands (init, build, run, test, fmt, lint, etc.) VS Code Extension—Syntax highlighting, completion, hover, diagnostics Package Managerfusion add/removeForge with cross-language deps Formatterfusion fmtAuto-formatting Linterfusion lintPolicy enforcement Documentationfusion docGenerate API docs Testingfusion testUnit + integration tests

Project Structure

Fusion v2.0 Vortex/
├── src/                    # Fusion source code (80+ .fu files)
│   ├── blockchain/         # 31 blockchain modules
│   ├── compiler/           # 19 compiler modules
│   ├── effects/            # Algebraic effects
│   ├── types/              # Linear, dependent, refinement, gradual
│   ├── tco/                # TCO + staging
│   ├── control/            # Continuations, coroutines
│   ├── security/           # Capabilities, provenance
│   ├── dispatch/           # Multiple dispatch
│   ├── actors/             # Actor model
│   ├── safety/             # Memory/type safety
│   ├── meta/               # Generics, macros, reflection
│   ├── concurrency/        # Threads, mutex, channels, async
│   ├── modules/            # Module system
│   ├── observability/      # Logging, metrics, profiling
│   ├── portability/        # Platform, serialization
│   ├── interop/            # Polyglot protocol
│   ├── integration/        # 30 cross-feature functions
│   ├── quantum/            # Quantum computing
│   ├── ml/                 # Machine learning
│   ├── ai/                 # AI inference
│   ├── net/                # HTTP, gRPC, TLS, WebSocket
│   ├── cloud/              # K8s, FaaS
│   ├── mobile/             # iOS, Android
│   ├── web/                # Web runtime
│   ├── runtime/            # Supernova, Cortex, Intent, HAFT
│   └── tests/              # Integration tests
├── stdlib/                 # 22+ standard library modules
├── crates/                 # Rust compiler crates
├── runtime/                # C runtime + Rust crates
├── tools/                  # CLI, VS Code, Forge
├── docs/                   # 27+ guide chapters + spec
├── installers/             # Platform installers
├── grammar/                # ANTLR4 grammar
├── examples/               # Example programs
└── Source Files/           # Reference implementations

Documentation

ChapterTopic Ch 1Installation, Hello World Ch 2Variables, types, operators, control flow Ch 3Data structures, pattern matching Ch 4Ownership, borrowing, Vortex Ch 5Generic types, trait bounds Ch 6I/O, strings, collections Ch 7ML-KEM-768, ML-DSA-65 Ch 8Gates, circuits, backends Ch 9Tensors, neural networks Ch 10Threads, async, actors Ch 11WASM compilation Ch 12CLI, formatter, linter Ch 1316 PLT features Ch 14Complete code examples Ch 15API reference Ch 16FFI, type mapping Ch 17Configuration Ch 18Feature toggle, witnesses Ch 26Blockchain development Ch 27Option/Result types

Full Reference: FUSION_LANGUAGE_SPEC.md (92KB comprehensive specification)

Examples

Hello World

fn main() -> void {
    println("Hello, Fusion v2.0 Vortex!");
}

Structs & Pattern Matching

struct Point {
    x: int,
    y: int,
}

fn classify(p: Point) -> string {
    match p.x {
        0 => "on y-axis",
        _ => "general point",
    }
}

fn main() -> void {
    let p = Point { x: 3, y: 4 };
    println(classify(p));
}

Post-Quantum Cryptography

fn main() -> void {
    let keypair = pqc_hybrid_keygen();
    let message = "Quantum-safe message";
    let signature = pqc_hybrid_sign(keypair, message);
    let valid = pqc_hybrid_verify(keypair, message, signature);
    println("Verified: " + valid);
}

Quantum Circuit

fn main() -> void {
    let circuit = quantum_circuit(2);
    circuit.h(0);
    circuit.cx(0, 1);
    let result = circuit.measure();
    println("Bell state: " + result);
}

Blockchain

fn main() -> void {
    let chain = chain_new(4);
    let tx = tx_new("alice", "bob", 100.0, 0.01);
    let block = pow_mine(block_new(chain_height(chain) + 1, block_hash(chain_latest(chain)), "tx"), pow_new(4));
    let updated = chain_add_block(chain, block_data(block));
    println("Chain length: " + chain_length(updated));
}

AI Model Inference

fn main() -> void {
    let model = fusion_llm_load_model("llama3");
    let response = fusion_llm_generate(model, "What is quantum computing?", 100);
    println(response);
}

Building

Prerequisites

  • Rust toolchain (rustup)
  • LLVM (for native compilation)
  • CMake (optional, for C runtime)

Build Commands

# Debug build
fusion build

# Release build
fusion build --release

# Build for WASM
fusion build --target wasm

# Run tests
fusion test

# Format code
fusion fmt

# Lint code
fusion lint

Environment Variables

# Development mode (allow cargo fallback)
export FUSION_FLUX_ENABLED=false
export ALLOW_CARGO_FALLBACK=true

# Production mode (strict enforcement)
export FUSION_STRICT_MODE=true

Contributing

We welcome contributions! Please see CONTRIBUTING.md.

Development Setup

git clone https://github.com/QuantumSecureTechnologiesInc/Fusion-Programming-Language.git
cd Fusion-Programming-Language
cargo build
cargo test

Building Installers

# Windows (NSIS)
makensis installers/windows/Fusion-Setup.nsi

# Linux (Debian)
dpkg-deb --build installers/linux/debian fusion-lang.deb

# macOS
pkgbuild --root installers/macos/root --identifier com.quantumsecure.fusion Fusion.pkg

Community

  • GitHub: QuantumSecureTechnologiesInc/Fusion-Programming-Language
  • Issues: Report a bug
  • Discussions: Join the conversation

License

This project is licensed under the MIT License - see the LICENSE file for details.

Built with post-quantum security for the quantum computing era

QuantumSecure Technologies LTD

Versions
2.0.0
Website
github.com
License
Last updated
9/1/2026
Download latest version
Loading...