Welcome to Rift
Rift is a game-changer for coding. Imagine taking any programming language you know—Python for its simplicity, JavaScript for its flexibility, C++ for its power, or even something less common like Ruby or Swift—and combining them all into one single project. That’s what Rift does. It doesn’t care where your code comes from; it pulls it all together seamlessly. Then, it lets you transform that mixed-up project into any language you want—maybe Rust if you’re after speed, or Java if you need something that runs everywhere. Once it’s ready, Rift can send your creation anywhere you choose: a blockchain like Ethereum or Solana, a cloud service like AWS or Google Cloud, or just your own laptop or phone. It’s designed for absolutely everyone. Whether you’re a game developer crafting the next big hit, a data analyst crunching numbers, a blockchain enthusiast building decentralized apps, or a massive company managing complex systems, Rift fits your world. It can handle tiny one-line scripts or gigantic projects with millions of lines of code, all without breaking a sweat.
What makes Rift truly special is its flexibility. You’re not stuck with one language or one destination. You can write a script that pulls in bits of code from all over—say, some Python for data work, some Go for fast networking, and some PHP from an old project—and Rift will weave them into one working piece. Then, if you want it to run faster or fit a specific system, Rift can rewrite it into whatever language suits you best, keeping everything intact. And when it’s time to launch, you don’t need a dozen tools—one command sends it to any blockchain, any cloud, or any device you’ve got. It’s powerful enough to tackle the toughest jobs, yet simple enough that you don’t need to be a coding genius to start playing with it. Whatever you’re building, wherever you’re taking it, Rift adapts to you.
Before You Begin
To use Rift, there are a few things you’ll need to set up on your computer. Don’t worry—it’s not complicated, and we’ll walk you through every step. Rift works on any system, whether you’ve got a Mac, a Windows PC, or a Linux machine. Here’s what you need to know before jumping in.
First, Rift runs on something called Rust. Rust is a programming language that’s fast and reliable, and it’s what powers Rift under the hood. You’ll need to install Rust to get started. If you’re on a Mac or Linux computer, open your terminal—that’s the app where you can type commands—and paste this: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh. Hit enter, and it’ll guide you through some options—just follow along and say yes to the defaults unless you’ve got a reason not to. When it’s done, type: source $HOME/.cargo/env and hit enter again. That makes sure Rust is ready to use. If you’re on Windows, it’s a little different—head to rust-lang.org in your browser, download the installer file, and double-click it to run it. Follow the steps it shows you, and when it’s finished, restart your command prompt or whatever app you use for typing commands. To make sure Rust is working, type this anywhere: rustc --version. If you see something like “rustc 1.x.x” pop up, you’re good to go. If not, double-check the steps or ask for help online.
Next, there are some optional tools that unlock Rift’s full potential. Rift can work with any programming language out there—Python, JavaScript, Java, PHP, Go, C++, or anything else you might use. To let Rift run or mix those languages, you’ll need their “toolchains” installed—the programs that make them work. These aren’t required right away; Rust alone gets you started, and you can add the rest as you need them. Here’s the rundown. For Python, type: python3 --version in your terminal or command prompt. If it’s not there, download it from python.org or use your system’s installer (like “sudo apt install python3” on Linux). For JavaScript, try: node --version—get it from nodejs.org if you need it. Java’s next: java -version—grab it from openjdk.org or oracle.com. PHP: php --version—php.net has you covered. Go: go version—find it at go.dev. C++: g++ --version—it’s often built into systems, or get Visual Studio for Windows. If you’ve got other languages in mind, like Ruby or Swift, just make sure their runtimes are installed too. Rift will adapt to whatever you throw at it, so pick what fits your projects.
That’s all you need to check before diving in. Rust is the must-have, and the language tools depend on what you want to play with. Once you’ve got these ready, you’re set to install Rift itself.
Install Rift
Installing Rift is straightforward and takes just a couple of minutes. It’s the same process whether you’re on Mac, Windows, or Linux, and you’ll be up and running before you know it.
Open your terminal or command prompt—whichever you use for typing commands. Type this: git clone https://github.com/zenyaga/rift-lang.git and hit enter. That downloads Rift to your computer from GitHub, a place where people share code. You’ll see some text scroll by as it grabs the files. When it’s done, type: cd rift-lang and hit enter. That moves you into the Rift folder you just downloaded.
Now, let’s build it. Type: cargo build --release and hit enter. This tells Rust to put Rift together—it’s like assembling a kit. Depending on your computer’s speed, this might take a minute or two. You’ll see some lines of text as it works, and when it’s finished, you won’t get a big “done” message, just the prompt back. That’s normal—it means Rift is ready.
That’s it for installation! You’ve got Rust set up, any extra language tools you want, and now Rift itself is built on your machine. Next, we’ll jump into using it with the Quick Start.
Quick Start
Let’s get Rift running and try it out. This is where you’ll see it in action for the first time, and it’s super easy to do, no matter what kind of computer you’re using—Mac, Windows, or Linux. We’ll walk through starting it, running a simple project, tweaking it, and sending it somewhere, all step by step.
To start Rift, open your terminal or command prompt and make sure you’re in the Rift folder—if you just installed it, you should already be there after typing “cd rift-lang”. Now, type: cargo run --release and hit enter. This launches Rift. After a moment, you’ll see a welcome message: “Rift v2.0.0 - Code Fusion Powerhouse,” followed by a prompt that says “rift>”. That “rift>” is where you’ll type commands to tell Rift what to do. If you see that, you’re in—Rift’s ready to roll.
First, let’s try a basic project to see how Rift mixes code. At the “rift>” prompt, type this: @rift hello { @fuse "python" { "print('Hello, Rift!')" } } and hit enter. Don’t worry about what it means yet—we’ll explain in the Syntax Guide—but this sets up a little project called “hello” with some Python code inside. Next, type: call hello; and hit enter. You’ll see something like: “python output: Hello, Rift!” followed by “Ok.” What just happened? Rift took that Python code, ran it, and showed you the result. It can do this with any language you’ve got installed—JavaScript, C++, whatever—so feel free to swap “python” for something else you like and try again.
Now, let’s tweak that project to show off Rift’s adaptability. At “rift>”, type: @task opt { @target "javascript" call optimize with hello; } and hit enter. This sets up a job called “opt” that will turn your “hello” project into JavaScript. Then, type: call opt; and hit enter. You’ll see a message like “Minion suggestion: Rewriting Python to JavaScript” pop up—Rift’s letting you know it’s doing the transformation. Finally, type: call optimized_hello; and hit enter. You’ll get: “javascript output: Hello, Rift!” with “Ok.” Rift took your Python code, rewrote it into JavaScript, and ran it—all automatically. You can pick any language here—Rust, Java, whatever—and Rift will adapt it just as easily.
Last step: let’s send your project somewhere. Type: @deploy "local" {} and hit enter. You’ll see something like: “Deployed locally: rift_power_1234567890” followed by “Ok.” Look in your Rift folder—a new file with a name like “rift_power_1234567890” will be there, holding your project. That’s the simplest deployment, saving it to your computer, but Rift can go anywhere. Swap “local” for “ethereum” or “aws” (you’d need some extra settings like API keys or region names, which we’ll cover later), and it’ll launch to a blockchain or cloud just as smoothly.
That’s your first taste of Rift! You’ve run it, mixed some code, tweaked it, and sent it somewhere—all in a few minutes. The Syntax Guide dives into every command so you can do more, Examples show off bigger projects, and Use Cases give you ideas to run with. If anything’s tricky, drop a note at github.com/zenyaga/rift-lang/issues—we’ve got your back.
Syntax Guide
This is your full guide to telling Rift what to do. It’s all about commands you type at the “rift>” prompt, one line at a time, hitting enter after each. Rift’s built to handle any language and any destination, and these commands let you mix, tweak, and launch your code however you want. We’ll explain each one—what it does, how to use it, and what it looks like in action—so you can master Rift step by step.
The Basics of How It Works
When you see “rift>” in the terminal, Rift’s waiting for you to give it instructions. Every command starts with a special word like @rift or @fuse, followed by details about what you want. You’ll type these commands one by one, and Rift processes each as you go. It’s like giving directions—tell it what to build, how to change it, or where to send it, and it follows along. Don’t worry if it sounds new; we’ll break it all down with examples.
@rift - Name Your Project
This command starts a new project and gives it a name so you can work with it later. You type: @rift myproject { and then list everything you want inside, ending with a }. The stuff inside is usually other commands like @fuse, which we’ll get to next. For example, if you type: @rift hello { @fuse "python" { "print('Hi!')" } } and hit enter, you’ve created a project called “hello” that has some Python code in it. The { and } are like brackets—they show where your project starts and stops. You can put as many things inside as you want, mixing different languages or adding more later. It’s your workspace, and the name (like “hello”) is how you’ll refer to it when you want to run or change it.
@fuse - Add Any Code
This is where Rift’s magic happens—it lets you drop in code from any language you can think of. You type: @fuse "language" { "code here" }. The “language” part is the name of whatever coding language you’re using—could be “python,” “javascript,” “java,” “php,” “go,” “cpp” for C++, or even something less common like “ruby” or “swift.” Rift’s built to recognize and run anything, as long as you’ve got the tools for that language installed (we covered those in Before You Begin). The “code here” part is the actual code you want to use, written exactly how you’d write it in that language. For instance, type: @fuse "javascript" { "console.log('Hey!')" } and hit enter. That adds some JavaScript to your project. You can stack these inside a @rift command—like @rift test { @fuse "python" { "print('Test')" } @fuse "go" { "package main import \"fmt\" func main() { fmt.Println(\"Go!\") }" } }—and Rift will hold onto all of them, ready to run or mix together.
@task - Set Up a Job
This command lets you plan out a change to your project, like turning it into a different language, and save that plan for later. You type: @task jobname { and then list the steps inside, ending with }. The “jobname” is whatever you want to call this plan—like “fast” or “web”—and the steps are other commands that say what to do. A common step is @target, which we’ll explain next. For example, type: @task fast { @target "rust" call optimize with hello; } and hit enter. This creates a job called “fast” that will take your “hello” project and rewrite it into Rust when you’re ready. You don’t have to run it right away—you’ll use “call fast” later to make it happen. It’s like setting up a recipe you can cook whenever you want.
@target - Choose a Language
This goes inside a @task and tells Rift what language you want your project turned into. You type: @target "language". The “language” can be anything—“rust” for speed, “python” for ease, “javascript” for web stuff, “java” for wide use, or any other language Rift can handle. It’s super flexible. For instance, inside a @task, you might type: @target "rust” and hit enter. That says “when this job runs, make my project Rust.” You’d pair it with a “call optimize” command (we’ll get to “call” soon) to do the actual transformation—like @task web { @target "javascript" call optimize with hello; } turns “hello” into JavaScript when you run it.
@deploy - Send It Anywhere
This command launches your project to a destination—anywhere you can imagine. You type: @deploy "place" { settings }. The “place” is where it’s going—could be “ethereum” for a blockchain, “solana” for another, “aws” for a cloud, “local” to save it on your computer, or any other platform or device Rift can reach. The “settings” part depends on where you’re sending it, and it’s written like key="value" pairs inside the { and }. For a simple one, type: @deploy "local" {} and hit enter—that saves your project as a file on your machine, with no extra settings needed. For something like AWS, you might type: @deploy "aws" { region="us-east-1" bucket="mybucket" function="myfunc" role="myrole" }, where those settings tell AWS where and how to put it. For Ethereum, it might be: @deploy "ethereum" { rpc_url="your-url" api_key="your-key" contract="your-contract" }. Rift’s ready for any destination—you just need the right settings, which depend on what that place expects (like API keys for blockchains or region names for clouds).
call - Make It Happen
This command runs something you’ve set up—a project, a job, or a transformed version. You type: call name and add a ; at the end to finish it. The “name” is whatever you called your @rift or @task. For example, if you made a project with: @rift hello { @fuse "python" { "print('Hi!')" } }, you’d type: call hello; and hit enter. Rift runs that Python code and shows the output—like “python output: Hi!” with “Ok.” If you set up a job with: @task fast { @target "rust" call optimize with hello; }, type: call fast; and hit enter—Rift will rewrite “hello” into Rust. After that, Rift makes a new version called “optimized_hello,” so you’d type: call optimized_hello; to run it and see the Rust version in action. The ; is like saying “go do it now”—it’s important for this command.
let - Store a Small Value
This command saves a simple piece of info, like a number, for later. You type: let name = value; with a ; to end it. The “name” is what you’ll call it, and “value” is what you’re saving—like a number or word. For example, type: let count = 5; and hit enter. That stores the number 5 under “count.” It’s not a big deal in Rift—most of the action happens with @rift and @fuse—but it’s there if you need to keep track of something small. You could use it later in an “if” or “while” command, which we’ll cover next.
if - Decide What to Do
This command checks something and runs code based on whether it’s true or not. You type: if condition { stuff to do } else { other stuff }. The “condition” is what you’re checking, and for now, Rift keeps it simple—use a number, where 0 means false and anything else (like 1) means true. The “stuff to do” is what happens if it’s true, and “other stuff” is what happens if it’s false. For example, type: if 1 { call hello; } else { call goodbye; } and hit enter. Since 1 is true, Rift runs the “hello” project (assuming you made one). The “else” part is optional—if you don’t need it, skip it, like: if 1 { call hello; }. It’s a basic way to make choices in Rift, and you can put any command—like “call”—inside the { and }.
while - Keep It Going
This command repeats something as long as a condition is true. You type: while condition { stuff to do }. Like with “if,” the “condition” is a number—0 stops it, anything else keeps it going. The “stuff to do” is what repeats. For example, type: while 1 { call hello; } and hit enter. That keeps running the “hello” project over and over because 1 is always true—be careful with this, as it won’t stop unless you force it (like hitting Ctrl+C in the terminal). A safer one might be: while 0 { call hello; }—that does nothing since 0 is false. It’s useful for looping, but Rift caps it at 10,000 repeats to avoid accidents.
How It All Fits Together
Here’s a full example to see the flow. Start with: @rift test { @fuse "python" { "print('Test')" } } and hit enter—that’s your project. Then: @task js { @target "javascript" call optimize with test; } and hit enter—that’s your job to turn it into JavaScript. Now run it: call test; and hit enter—you’ll see “python output: Test” with “Ok.” Next: call js; and hit enter—Rift rewrites it, showing “Rewriting Python to JavaScript.” Finally: call optimized_test; and hit enter—you’ll see “javascript output: Test” with “Ok.” That’s Rift mixing, tweaking, and running, all in a few lines.
Quick Tips to Remember
When you’re using “call” or “let,” end with a ;—it’s like a green light to go. Use { and } to wrap sections—like inside @rift or @task—to keep things organized. Put language names and code in “quotes” so Rift knows what’s what. Type one line at a time and hit enter—Rift waits for each step. If you mess up, it’ll say something like “Parse error”—just try again.
That’s the whole toolbox! Rift can take any code you give it and send it anywhere you point. The Examples section has bigger projects to try, and Use Cases lists ways to use it—dive in and experiment.
Examples
Seeing Rift work is the best way to get it. Here are three examples—from simple to wild—to show what it can do. Type these at “rift>”, hitting enter after each line, and watch Rift handle any language and any destination.
Example 1: Simple Blend
Let’s mix two languages into one project. Type: @rift greet { @fuse "python" { "print('Hi from Python')" } @fuse "javascript" { "console.log('Hi from JS')" } } and hit enter. This creates a project called “greet” with Python and JavaScript code inside. Now, type: call greet; and hit enter. You’ll see: “python output: Hi from Python” and “javascript output: Hi from JS” followed by “Ok.” What’s happening here? Rift takes those two bits of code, runs them one after the other, and shows you the results. It doesn’t matter what languages you pick—swap “python” for “go” or “cpp” if you’ve got them installed—and Rift will mix them just as easily. This is the simplest way to see Rift’s power: combining anything into one smooth run.
Example 2: Speed Up
Now let’s take some code and make it faster. Type: @rift upload { @fuse "php" { "
Example 3: Full Power
Let’s go big—mix three languages, tweak them, and send them everywhere. Type: @rift monster { @fuse "python" { "import tensorflow as tf; print(tf.matmul([[1,2],[3,4]], [[5,6],[7,8]]))" } @fuse "go" { "package main import \"log\" func main() { log.Println(\"Go power\") }" } @fuse "cpp" { "struct V { double x; }; V add(V a, V b) { return {a.x + b.x}; } int main() { V a{1}, b{2}; add(a,b); }" } @task opt { @target "rust" call optimize with monster; } } and hit enter. This creates a “monster” project with Python doing math, Go logging a message, and C++ adding numbers, plus a job to turn it all into Rust. Start with: call monster; and hit enter—you’ll see “python output: [[19 22] [43 50]]” (a matrix multiplication), “go output: Go power,” and nothing from C++ since it runs silently, all with “Ok.” Next: call opt; and hit enter—Rift will say “Minion suggestion: Rewriting Python to Rust,” “Rewriting Go to Rust,” and “Rewriting C++ to Rust” as it transforms everything. Then: call optimized_monster; and hit enter—you’ll get Rust versions like “rust output: [[19.0, 22.0], [43.0, 50.0]],” “rust output: Kubernetes node started,” and “rust output: Result: 3, 0, 0” with “Ok.” Finally, type: @deploy "all" { rpc_url="mock" program_id="mock" api_key="mock" contract="mock" region="us-east-1" bucket="test" function="monster" role="mock" } and hit enter. You’ll see “Deployed to Ethereum: (artifact),” “Deployed to Solana: (artifact),” “Deployed to AWS Lambda: monster,” and “Deployed locally: rift_power_somenumber” with “Ok.” These are mock settings for now, but with real ones, it’d hit those platforms live. This shows Rift’s full strength—any languages, any transformations, any destinations, all in one go.
Why These Matter
The first example is dead simple—mix any languages you like, and Rift makes it work. The second digs deeper—take code from anywhere and turn it into anything, keeping it useful. The third is a powerhouse—big projects with multiple sources, transformed and launched everywhere. Rift handles it all, no limits.
Use Cases
Rift’s built for everyone and every idea—it takes any language and deploys anywhere. Here’s a long list of ways it can fit into your world, whether you’re coding for fun, work, or something massive. Each one’s a starting point—try it and see where it takes you.
1. Blockchain Apps
Imagine mixing code that talks to blockchains—like C++ for smart contracts—with web code like JavaScript for a slick interface. Rift pulls it into one project and sends it to any blockchain—Ethereum, Solana, Binance Smart Chain, whatever you’re into. It’s perfect for building decentralized apps fast, without juggling separate tools. You get one script that does it all, ready to launch.
2. Data and AI Work
Picture combining Python’s data tools—like TensorFlow for machine learning—with fast code like C++ for heavy math. Rift blends them together, then lets you tweak it into any language—Rust for speed, Python to keep it simple—and run it anywhere, from your laptop to a cloud server. It’s great for crunching numbers, training AI models, or analyzing huge datasets, all in one smooth flow.
3. Cloud Tasks
Think about fusing old scripts—like PHP from a legacy site—with modern multitasking code like Go. Rift makes it one project and launches it to any cloud—AWS, Google Cloud, Azure, you name it. It’s ideal for automating jobs across different systems, whether you’re moving files, processing data, or running backups, all without rewriting everything.
4. Apps for Every Platform
Imagine blending desktop code—like Java for a program—with web code like JavaScript for a browser version. Rift combines them and adapts it to any language—JavaScript for web, Rust for mobile—so it runs on phones, computers, or browsers from one build. It’s a dream for making tools that work everywhere without starting over for each platform.
5. Refreshing Old Code
Got some ancient code—like PHP from a decade ago or C++ from an old app? Rift pulls it in and turns it into something new—any language, like Python for ease or Rust for power. It’s like a time machine for your projects, letting you revive stuff without the hassle of rewriting it by hand.
6. Building Games
Picture mixing fast game logic—like C++ for physics—with easy scripting—like Python for story bits. Rift fuses them and tweaks it to any language—Rust for speed, JavaScript for web games. It’s awesome for crafting games that run smooth and quick, whether you’re an indie dev or just experimenting.
7. Smart Device Ideas
Think about combining hardware code—like Go for a sensor—with a display—like JavaScript for a dashboard. Rift blends them and sends it anywhere—your device, a server, wherever. It’s perfect for quick prototypes, like smart lights or trackers, letting you test ideas fast.
8. Data Flows
Imagine fusing data tools—like Python for stats—with connectors—like Java for databases. Rift makes it one project and adapts it to any language—Rust for efficiency, Python for simplicity—running anywhere you need. It’s great for pulling info from all over into one clean stream, like reports or live updates.
9. Teaching Coding
Picture showing how different languages—like Python, JavaScript, C++—solve the same problem, all in one script. Rift mixes them together, making it a fun tool for teaching or learning. You can compare side-by-side and see how coding works across the board, perfect for classrooms or self-study.
10. Blockchain Stats
Think about blending data analysis—like Python for charts—with blockchain queries—like Go for chain data. Rift combines them and launches it anywhere—a cloud, your machine—giving you real-time insights from crypto networks. It’s a slick way to track trends or stats without splitting your work.
More Ways to Use It
Microservices: Fuse backend code with frontend stuff—like Java and JavaScript—into one package, deployable to any cloud. Security Tools: Mix fast code with scripts—like C++ and Python—for testing systems, sending it anywhere. Mobile Helpers: Blend APIs with scaling—like PHP and Go—into any language for apps. Chatbots: Combine language skills with interfaces—like Python and JavaScript—launchable wherever. Science Work: Fuse math code with visuals—like C++ and Python—adaptable to any system.
Rift’s got no ceiling—any language you know, any place you want it, any project you can dream up. Start small or go huge; it’s ready for you.