Forem: Prathmesh barot

Building Rynex: A 175KB TypeScript Framework Without Virtual DOM

Prathmesh barot — Tue, 21 Oct 2025 11:16:21 +0000

The Problem with Modern Framework Overhead

Most modern web frameworks ship with Virtual DOM implementations that add significant bundle size before you write a single line of application code. For small to medium-sized web applications, this overhead often feels unnecessary. After working on multiple projects and consistently running into this issue, I decided to explore an alternative approach.

Introducing Rynex

Rynex is a zero-configuration TypeScript framework for building reactive web applications without Virtual DOM. Instead of maintaining a virtual representation and performing diff operations, Rynex uses direct DOM manipulation combined with proxy-based reactivity to achieve fast, efficient updates.

The core principle is simple: when state changes, Rynex updates only the affected DOM nodes directly. No diffing algorithm, no reconciliation phase, just targeted updates where they are needed.

Key Features

Rynex comes with a comprehensive set of features designed for modern web development:

Developer Experience:

Zero-configuration TypeScript setup with full type safety
Next.js-style file-based routing system
Built-in Express development server with Hot Module Replacement
Integrated Tailwind CSS support out of the box

Performance:

Approximately 175KB gzipped bundle size for the core framework
Direct DOM updates via JavaScript Proxies
Batched updates to prevent unnecessary re-renders
Minimal runtime overhead

Built-in Utilities:

UI component helpers including grids, modals, and form utilities
Reactive state management system
Dynamic routing with parameter support
Production build optimization

Technical Architecture

The framework leverages JavaScript Proxies to create a reactive system that tracks state mutations and automatically updates the corresponding DOM elements. The routing system follows a file-based approach similar to Next.js, where the directory structure in your pages folder automatically generates application routes.

The bundling process is optimized to produce minimal output while maintaining full TypeScript type checking. The development server provides instant Hot Module Replacement for a smooth development experience.

Current Development Status

Rynex is approximately 75 percent complete. The core routing system and state management functionality are solid and production-ready. The development server, build pipeline, and TypeScript integration are fully functional.

Areas currently under active development include comprehensive documentation, expanding test coverage, handling additional edge cases, and building out the component library ecosystem.

Performance Considerations

The trade-offs of direct DOM manipulation versus Virtual DOM are context-dependent. For applications with simple to moderate reactive patterns, direct updates can be faster and more memory-efficient. For extremely complex scenarios involving thousands of list items with frequent updates, Virtual DOM diffing may still provide advantages.

Initial performance testing shows promising results for typical web application use cases, but comprehensive benchmarking against other frameworks is ongoing.

Try It Out

The best way to understand Rynex is to see it in action:

Live Demo: https://rynex-demo.vercel.app/

Source Repositories:

Framework Repository: https://github.com/razen-core/rynex
Demo Application: https://github.com/razen-core/rynex-demo

Visit the GitHub repository to explore the source code, review the architecture, and see detailed implementation. The demo application showcases routing, state management, and various UI components in a real-world context.

Looking Forward

The roadmap to version 1.0 focuses on three main areas: comprehensive documentation with real-world examples and migration guides, expanded test coverage across all core functionality, and performance benchmarking against established frameworks.

Beyond that, planned features include a plugin system for extensibility, component lifecycle hooks, and an ecosystem of reusable components.

Community Feedback Welcome

This project is open source and community feedback is invaluable. Whether you have thoughts on the architecture, suggestions for features, or questions about use cases, your input helps shape the direction of development.

If this approach to building web applications interests you, check out the repositories and try the live demo. Contributions, suggestions, and discussions are all welcome.

Built by Prathmesh Barot from Razen Core

GitHub: https://github.com/razen-core

Razen v1.1-preview.0 Release

Prathmesh barot — Sun, 05 Oct 2025 11:44:27 +0000

feat: Complete Razen rewrite to v1.1-preview.0 with RAJIT architecture

Entirely rewritten language with all new features and improvements
Introducing RAJIT (Razen Adaptive JIT Compiling) architecture
3-tier system: Native JIT, bytecode, and runtime for optimal performance
100% better than previous versions with enhanced stability
Updated README and version references throughout

Github: https://github.com/BasaiCorp/Razen-lang
Reddit: https://www.reddit.com/r/razen_lang
Twitter/X: https://x.com/razenlang

Razen Beta v0.1.75 - Library Call Update & Namespace Notation

Prathmesh barot — Fri, 06 Jun 2025 15:22:37 +0000

Release Date: June 5, 2025

Status: Beta

Notice:
Razen previously supported only the bracket notation for library calls (e.g., Lib[func](...)). This notation is still valid and will continue to work until the release of beta v0.1.80. After that, only the modern namespace notation (lib::function(...)) will be supported. Please update your code accordingly.

For more details and ongoing updates, visit our main website: https://razen-lang.vercel.app/

Changelog page: https://razen-lang.vercel.app/changelogs

What's New

Powerful Library Call System

Namespace Notation (lib::function): You can now call library functions using the modern namespace::function(args...) syntax, in addition to the classic Library[function](args...) bracket notation.
Full Parity: Both bracket and namespace notations are fully supported and interchangeable for all standard and custom libraries.
Improved Parser & Compiler: The parser and compiler have been enhanced to robustly handle complex library calls, including nested and chained calls, across all supported libraries.

Modernized Library Experience

Consistent Metadata Extraction: All documentation and sidebars now display function difficulty and version badges, auto-updated from library sources.
Color-coded Difficulty & Version Badges: Instantly see the complexity and stability of each library function.
Semantic Sorting: Changelogs and docs are now sorted by version and difficulty for easier navigation.

Usability & Error Handling

Better Error Messages: Parser errors now include precise line and column info, making debugging easier.
Graceful Handling of Invalid Calls: Unhandled or invalid library calls now produce clear, actionable error messages.
Backward Compatibility: All previous scripts using bracket notation continue to work without changes.

Technical Improvements

Namespace Operator Registered: The :: operator is now a first-class infix operator in the parser, enabling robust namespaced calls.
Unified Expression Handling: Library calls, whether via brackets or namespace, are parsed into a unified AST structure for consistent compilation.
Test Coverage: New and extended tests ensure both notations work identically for all libraries.

Migration Guide

No migration needed immediately! All previous code using Library[function](...) still works. However, bracket notation will be deprecated after beta v0.1.80. Please migrate your code to use lib::function(...) for future compatibility.

Example

lib arrlib;
lib strlib;

show arrlib::push([1,2,3], 4);     # Namespace notation
show ArrLib[push]([1,2,3], 4);     # Bracket notation (still supported)
show strlib::upper("hello");      # Namespace notation
show StrLib[upper]("hello");      # Bracket notation

Documentation & Sidebar Updates

Docs, examples, and changelogs now auto-update from library metadata.
Difficulty and version badges are displayed everywhere for clarity.

Special Thanks

Thanks to the Razen community for feedback and bug reports!

Full Changelog

Added: Namespace notation (lib::function) for all library calls
Improved: Parser and compiler robustness for all library call forms
Improved: Error reporting for invalid library calls
Improved: Documentation and sidebar metadata extraction
Fixed: Legacy bugs with chained and nested library calls
Fixed: Sorting and badge display in docs and changelogs
Maintained: Full backward compatibility with bracket notation

If you're interested in testing Razen, feedback, or want to help out or contribute, check these links:

GitHub Repo: https://github.com/BasaiCorp/Razen-Lang

Subreddit: https://reddit.com/r/razen_lang (not promoting just for info - I post updates here and you can also post issues and other stuff)

Website: https://razen-lang.vercel.app (don't have money to buy .org or .dev domain so this is enough for now)

Razen Programming Language beta v0.1.695

Prathmesh barot — Fri, 30 May 2025 07:32:29 +0000

Announcing Razen v0.1.695: Streamlining the Language and Supercharging Error Handling 🚀 (Beta)

Hey Dev.to fam! 👋

I’m thrilled to share a new milestone for Razen, the programming language I’ve been passionately developing. We’ve just released v0.1.695, now in Beta, focused on making Razen leaner, more reliable, and developer-friendly — especially when it comes to error handling and library support.

Why Beta?

Razen is still early-stage but rapidly evolving. The Beta status means:

The core syntax and libraries are mostly stable, ready for serious exploration
We’re actively gathering community feedback to shape future features
Some APIs and tokens are still in flux (like the recent token removals), aiming for a clean, maintainable language

If you like being on the cutting edge, diving into language design, or helping steer a language from ground zero, this is a perfect time to jump in.

What’s New in v0.1.695?

✨ Enhanced Error Handling — Because Bugs Happen

Robust try-catch-finally ensures your cleanup always runs
Clearer error messages with line and column details
Nested exceptions support for complex error flows

📚 Library System Revamp

Faster library imports for a smoother dev experience
StrLib now packs more punch with advanced string operations
TimeLib handles all your date/time needs cleanly and consistently

Cleaning House: Token Removal for Simplicity

Based on community feedback, we removed some redundant tokens, especially around strings and date/time. This makes Razen easier to learn, parse, and maintain:

String operations use StrLib functions instead of dedicated tokens
Date/time now handled through TimeLib functions

Migration Example

lib strlib;
lib timelib;

# Before
text greeting = "Hello, World!";
concat fullName = "John" + " " + "Doe";
slice firstName = "John Doe"[0:4];
len nameLength = "John Doe".length;

# After
take greeting = "Hello, World!";
take firstName = StrLib[substring]("John Doe", 0, 4);
take nameLength = StrLib[length]("John Doe");

# Date & Time
let currentTime = TimeLib[now]();
let year = TimeLib[year](currentTime);
let month = TimeLib[month](currentTime);

Why This Update Matters

By simplifying the language and beefing up error handling, Razen becomes:

More intuitive for new and experienced devs alike
More performant under the hood
Easier to maintain and extend as the language matures

Join Us on This Journey

Razen is an evolving Beta project, and your feedback is invaluable! Try it out, experiment, break things, and share your thoughts:

Let’s build something great together — a language that respects the wisdom of the past but embraces the future.

Thanks for reading and being part of the dev community! If you want tutorials, deep dives, or to discuss language design, just say the word.

— Prathmesh, Creator of Razen

Introducing #razenlang — A Clean, Fast & Beginner-Friendly Programming Language

Prathmesh barot — Sun, 06 Apr 2025 05:48:41 +0000

Hey Devs! 👋

I'm super excited to launch a new programming language I've been building: Razen Lang — and with it, a new official Dev.to tag: #razenlang!

🌟 Razen is fast, minimal, and beginner-friendly — with a syntax cleaner than Python and a modular approach inspired by real-world dev workflows.

🔖 About the Tag `#razenlang`

This tag is for anything related to Razen Lang:

Tutorials, examples, and projects built in Razen
Changelogs, beta features, and updates
Developer discussions, ideas, and improvements
Contributions to the language (it's open source!)
Questions or suggestions from early adopters

Whether you’re exploring new languages or just want something refreshing, join the journey!

🛠️ About Razen Lang

Razen Lang is:

🧠 Beginner-friendly and super readable
⚡ Fast with light syntax and expressive structure
🧩 Modular with support for razen-run, razen-help, razen-update, razen-debug, and more
📦 Growing with 30%+ standard library, module import/export, and developer tools

A new beta version is launching tomorrow with new CLI tools, better developer experience, and community-focused features!

🙌 How You Can Help

✅ Use the #razenlang tag in your posts

✅ Try the language from GitHub: 🔗 Razen Lang Repo

✅ Give feedback, report issues, or contribute

✅ Follow me and star the repo

✅ Drop a comment if you're interested in exploring or building with Razen!

Let’s grow #razenlang into something awesome together 💜

Happy coding!

—

Razen Dev Team (aka: just me for now 😄)

🚀 Introducing Razen Lang — A Simple, Fast & Friendly Programming Language for Developers

Prathmesh barot — Sun, 06 Apr 2025 05:44:20 +0000

🚀 Getting Started with Razen Lang — *Simple, Fast & Developer-First Programming Language**

Razen Lang is a beginner-friendly, blazing fast, and minimal programming language I've been building from scratch.

Designed to be faster than Python, cleaner to read, and fun to use, Razen puts developers first — whether you're brand new to code or building powerful tools!

✨ Why Razen Lang?

The idea is simple — build a language that’s:

✅ Clean & readable syntax

✅ Minimal keywords but powerful tools

✅ Super easy to learn (great for beginners!)

✅ Fast like lightning ⚡

✅ Built with ❤️ for the developer experience

📦 Installation Guide

🚧 No universal install command yet — install is OS-specific.

👉 Head to the official GitHub repo for full setup instructions:

🔗 GitHub: BasaiCorp/Razen-Lang

Includes:

🛠️ Setup Guides | 📄 Release Notes | 🧪 Usage Examples

🧰 Developer CLI Tools — Comfort Commands

Razen comes with built-in CLI tools designed to supercharge your dev flow:

razen-help          # 🧠 View docs and command usage in terminal  
razen-run file.rzn  # ⚡ Instantly run any .rzn script  
razen-debug file.rzn# 🐞 Debug with step logs + error tracking  
razen-update        # 🔄 Pull the latest build or patch  
raze new new.rzn    # ✨ Instantly create a new starter script

💡 No extra tools required — works right from your terminal!

🔥 Core Language Features

Here’s what Razen already supports:

🧾 Clean variable declarations (let, take, hold)
➕ Math operations (sum, diff, prod)
🧠 Logic & conditions (if, is, not)
🔠 Strings, 📦 Arrays, 🗺️ Maps, 🧾 Lists
🧩 Script types: script, cli, web
💾 Storage types: store, box, ref
🕒 Built-in date/time support
🎯 Input/Output
🔁 Loops and 🧩 Functions

🛠️ Changelog – Latest Dev Build Highlights

✅ New Features Recently Added:

📦 Module Import/Export System
🧪 razen-test — Testing Framework
🧠 Smart Variable Handling
🙌 Friendly Syntax Errors
🧾 Improved Data Type Handling
🔧 CLI Tools (run, debug, update, help)
✨ New Script Generator (raze new)
📘 Beginner Usage Guide added to /usage

🚧 What’s Coming in the Next Beta?

💥 The next beta version drops tomorrow with major upgrades!

✅ Already Added for Beta:

🧪 razen-test — Write & run test blocks
🧰 30% of Standard Library structured
🧠 CLI Tools + Debug Tracking
🗂️ Templates for script/cli/web projects

🛠️ In Progress:

📦 Enhanced module system (nested imports)
📊 Test logs with results + error line reporting
🔁 Final integration of the full standard library
📦 Planning: Razen Package Manager

💬 Community & Support

Razen is starting to gain love from developers on DEV.to, GitHub, and more.

Want to be a part of the journey?

✨ Star the Repo on GitHub

💬 Share your thoughts on DEV.to

🛠️ Suggest features, open issues, or contribute

🎯 Final Notes

Razen Lang is built with passion for developers — offering speed, simplicity, and a smooth learning curve. With rich CLI tools, beginner-friendly syntax, and growing feature support, it’s made for you.

🔜 Coming Soon:

🚀 Beta release
🧪 Full testing support
📦 Package management system
🧠 More documentation & templates

👉 Ready to Try Razen?

✅ Explore the language

✅ Try out the CLI tools

✅ Drop feedback & ideas

✅ Help shape the future of Razen 🚀

Razen Lang Guide: Simple, Fast, and Developer-Friendly

Prathmesh barot — Sun, 06 Apr 2025 03:16:45 +0000

Getting Started with Razen Lang

Razen Lang is a beginner-friendly programming language designed for simplicity, readability, and ease of use. This guide covers everything you need to start writing Razen code, from installation to core language features.

Installation

Razen Lang supports multiple operating systems with platform-specific installation methods. Visit the official GitHub repository for detailed installation instructions for your system:

GitHub Repository: BasaiCorp/Razen-Lang

The repository contains installation guides, examples, and the latest updates.

File Structure

Every Razen program begins with a module declaration:

mod main;

fun main() {
    println("Hello, World!");
}

Variables and Constants

Razen provides two ways to declare variables: mutable and immutable.

Immutable Variables

Use const for values that won't change:

const name: str = "Razen";
const version: int = 1;
const pi: float = 3.14159;

Mutable Variables

Use var for values that can be modified:

var age: int = 25;
var is_active: bool = true;
var balance: float = 1000.50;

Data Types

Razen supports several built-in data types:

Primitive Types

const number: int = 42;
const text: str = "Hello, Razen!";
const flag: bool = true;
const letter: char = 'R';

Collections

const numbers: array<int> = [1, 2, 3, 4, 5];
const user_data: map<str, any> = {
    "name": "Alice",
    "age": 30,
    "active": true
};

Dynamic Typing

var data = "flexible content";
data = 42;  // Can be reassigned to different types

Functions

Define functions using the fun keyword:

fun greet(name: str) -> str {
    return f"Hello, {name}!"
}

fun add_numbers(a: int, b: int) -> int {
    return a + b
}

fun main() {
    const message = greet("World")
    println(message)

    const result = add_numbers(5, 3)
    println(f"5 + 3 = {result}")
}

Control Flow

Conditional Statements

const age = 18

if age >= 18 {
    println("You are an adult")
} elif age >= 13 {
    println("You are a teenager")
} else {
    println("You are a child")
}

Loops

// While loop
var counter = 0
while counter < 5 {
    println(f"Count: {counter}")
    counter++
}

// For loop
const items = ["apple", "banana", "cherry"]
for item in items {
    println(f"Fruit: {item}")
}

// Range-based loop
for i in 1..10 {
    println(f"Number: {i}")
}

Pattern Matching

Use match for powerful pattern matching:

const value = 42

match value {
    0 => println("Zero"),
    1..10 => println("Small number"),
    42 => println("The answer!"),
    _ => println("Something else")
}

Error Handling

Razen provides structured error handling:

fun divide(a: int, b: int) -> int {
    try {
        if b == 0 {
            throw "Division by zero";
        }
        return a / b;
    } catch error {
        println(f"Error: {error}");
        return 0;
    }
}

Input and Output

Console I/O

println("Enter your name:")
const user_name = input()
println(f"Hello, {user_name}!")

print("Loading")  // No newline
println("... Done!")

File I/O

const file_handle = open("data.txt", "r")
const content = read(file_handle)
close(file_handle)

const output_file = open("output.txt", "w")
write(output_file, "Hello, File!")
close(output_file)

Modules and Imports

Creating Modules

// math_utils.rzn
mod math_utils

pub fun square(x: int) -> int {
    return x * x
}

pub const PI: float = 3.14159

Using Modules

mod main

use "math_utils"
use {square, PI} from "math_utils"
from "math_utils" use square as sq

fun main() {
    const result = square(5)
    println(f"Square of 5: {result}")
    println(f"PI value: {PI}")
}

Structures and Enums

Defining Structures

struct Person {
    name: str,
    age: int,
    email: str
}

fun main() {
    const person = Person {
        name: "Alice",
        age: 30,
        email: "alice@example.com"
    };

    println(f"Name: {person.name}")
    println(f"Age: {person.age}")
}

Defining Enums

enum Status {
    Active,
    Inactive,
    Pending
}

fun check_status(status: Status) {
    match status {
        Status::Active => println("User is active"),
        Status::Inactive => println("User is inactive"),
        Status::Pending => println("User status is pending")
    }
}

String Interpolation and Formatting

Razen supports modern string interpolation:

const name = "Razen"
const version = 1.0

const message = f"Welcome to {name} version {version}!"
println(message)

// Raw strings
const file_path = r"C:\Users\Documents\file.txt";
const multiline = """
This is a
multiline string
in Razen
""";

Comments and Documentation

// Single-line comment

/*
 * Multi-line comment
 * for detailed explanations
 */

/// Documentation comment for functions
/// This function calculates the factorial of a number
fun factorial(n: int) -> int {
    if n <= 1 {
        return 1
    }
    return n * factorial(n - 1)
}

Complete Example

mod calculator

struct Calculator {
    history: array<str>
}

impl Calculator {
    pub fun new() -> Calculator {
        return Calculator {
            history: []
        }
    }

    pub fun add(&mut self, a: int, b: int) -> int {
        const result = a + b;
        self.history.push(f"{a} + {b} = {result}")
        return result
    }

    pub fun show_history(&self) {
        println("Calculation History:")
        for entry in self.history {
            println(f"  {entry}")
        }
    }
}

fun main() {
    var calc = Calculator::new()

    const sum1 = calc.add(10, 5)
    const sum2 = calc.add(20, 15)

    println(f"Results: {sum1}, {sum2}")
    calc.show_history()
}

Next Steps

To continue learning Razen Lang:

Check the GitHub repository for more examples
Read the language specification for advanced features
Join the community discussions and contribute to the project
Build small projects to practice the syntax and concepts

Happy coding with Razen Lang!

Introducing Razen Lang – A Lightweight, Beginner-Friendly Language 65% Simpler Than Python!

Prathmesh barot — Sat, 05 Apr 2025 14:49:59 +0000

🚀 Introducing Razen Lang: A Super Fast, Lightweight Programming Language (65% Simpler than Python!)

Hello fellow developers! 👋

I've been building a new programming language called Razen Lang — a lightweight, ultra-fast language designed for scripting, prototyping, and small tools, with Python-inspired syntax and modern features.

🔥 Key Features:

✅ Super lightweight and optimized for speed
✅ 65% easier to learn than Python (based on simplified syntax and cleaner structure)
✅ Python-like syntax (perfect for beginners and quick scripting)
✅ Built-in debugging tools for faster development
✅ Minimalistic and fast interpreter
✅ Open source & actively maintained
🧪 Currently in Beta – expect rapid updates, improvements, and new features

I’m looking for early testers, contributors, and feedback to make Razen Lang better.

Whether you're into compilers, language design, or just love trying new tools — I’d love your help!

🔗 GitHub Repo: https://github.com/BasaiCorp/Razen-lang

Please check it out, run a few sample scripts, and let me know:

What works well?
What’s confusing?
What should I add/improve?

💬 Feel free to open issues, submit PRs, or just leave feedback!

Thanks for reading — let’s make something awesome together 🧠🚀