Dorpn v0.4.2 (Windows)

Dorpn v0.4.2 Changelog

Added

• imm keyword - Runtime-initialized immutable variable. Value can be set once at runtime (e.g. from user input) but cannot be reassigned.

func _Start():
    imm name : String = ask("What's your name? ")
    print("Welcome,", name)

    # name = "someone else"   -> compile-time error, imm cannot be reassigned 

• Explicit type conversions - 5 new methods with no implicit coercion, in line with strict typing:
  • asInt() : Int32 | Float | String -> Int
  • asFloat() : Int | Int32 | Float32 | String -> Float
  • asString() : Any -> String
  • asInt32() : Int -> Int32 (narrowing)
  • asFloat32() : Float -> Float32 (narrowing)

tag x : Int = 42
tag y : Float = x.asFloat()
tag n : Int = "123".asInt()

• Built-in control functions - 3 new functions for controlling program execution:
  • panic(msg) - immediately halts execution with an error message (defaults to a generic message if omitted)
  • finish() - exits the program successfully (exit code 0)
  • error_out(code) - exits the program with a specific error code (defaults to 1 if omitted)

func validateAge(age :Int):
    if age < 0:
        panic("Age cannot be negative")
    if age > 150:
        error_out(2)

func _Start():
    print("Starting up...")
    finish()

Fixed

• Const now enforces compile-time values only. Runtime values are rejected.
• Fixed crash when a Const references another Const (e.g. Const B = A * 2). Constants are now emitted as compile-time literals.
• Function declarations without () now correctly throw a syntax error.
• Fixed compound assignments (+=, -=, *=, /=, %=) being silently discarded, which could cause infinite loops.
• Fixed blank lines in indented blocks with CRLF line endings prematurely closing function bodies.
• Fixed \r escape sequence in strings emitting r instead of carriage return.
• Undefined variables with method calls (e.g. undefinedVar.repeat(3)) are now correctly flagged.
• Fixed type inference for method chains (.repeat(), .size(), etc.) in analyzer and JS codegen.
• String -> Int / Float conversions now panic on invalid input instead of returning 0.

Changed

• Clearer separation between tag (mutable), imm (immutable, runtime), and Const (immutable, compile-time).
• Narrowing conversions (Int -> Int32, Float -> Float32) now panic on overflow with runtime range checks.
• All 5 conversion methods are now supported consistently across C and JS backends with identical panic behavior.

Known Issues

• JS backend: type() may report "Int" for Float values holding whole numbers (e.g. 42.0) due to JS number representation.

Dorpn v0.4.1 (Windows)

Dorpn v0.4.1 — Strict & Stable

Dorpn is leveling up! This release focuses on discipline, stability, and smoother upgrades.

✨ Highlights

• Experimental --upgrade flag — try updating Dorpn with a single command (still in testing).
  dorpn --upgrade
• Strict syntax & indentation — colons are now required at block headers, and only 2 or 4 spaces are allowed per indent.
• Better error handling — multiple semantic errors reported at once, with colorful categorized output.
• Safer ask() — prompt must be a String, no silent type mismatches anymore.
• Runtime path fix — compiler now always checks its install location for runtime files, so no more “runtime file not found” errors.

🛠 Fixes

• Empty input in ask() no longer leaves blank lines.
• Deprecated types (String32, Bool32) fully removed.
• Invalid type names now throw proper syntax errors.
• Reassignment type checks finally enforced.
• keep loops are now fully type‑checked.
• Runtime file resolution fixed (compiler no longer depends on user directory path).

🔄 Upgrading from v0.4.0

• Add : to all block headers.
• Use consistent 2 or 4 space indentation.
• Replace String32/Bool32 with String/Bool.
• Ensure ask() prompts are String.
• Expect stricter checks inside keep loops.

Dorpn v0.4.0 (Windows)

Dorpn v0.4.0 — JavaScript is Here

We are glad to announce that now v0.4.0 brings JavaScript compilation to Dorpn, making it the first release where a single .dpn file can target two completely different runtimes — compiled native binary via C, or executed in any JavaScript environment.

---

What's New

JavaScript Compilation Support

Dorpn can now compile to JavaScript. Write your code once in .dpn and choose at build time whether you want a native C binary or a JavaScript output. Both targets share the same language, the same syntax, and the same standard runtime functions — the backend does the heavy lifting.

This opens Dorpn up to environments where a native binary isn't practical, including Node.js runtimes, scripting contexts, and future browser-facing use cases.

New Compiler Flags: -js and --Javs

Two new flags have been added to the compiler to control compilation target:

• -js — compiles the .dpn source to JavaScript output.
• --Javs — alternative flag for the same JavaScript compilation target.

Without either flag, the compiler defaults to the existing C backend as before. Nothing about the current C workflow has changed.

void Keyword

The void keyword has been added to the language. It can be used to explicitly mark a function, loop, or condition block as returning nothing. This is useful for making intent clear — particularly in functions that perform side effects and are not expected to produce a value.

func greet(name: String):    
    void    # pass function greet

---

Notes on JavaScript Backend

Please note: While Dorpn v0.4.0 introduces JavaScript compilation, certain features are currently supported only in the native C runtime.

The JavaScript backend focuses on portability and scripting use cases, so such features may not be available or may behave differently. Future releases will expand compatibility.

---

Deprecation Notice

After further research, we found that 8‑bit types deliver stronger default performance compared to 32‑bit variants. To keep the language efficient and consistent, we have decided to revert to the default design and remove unnecessary 32‑bit constructs.

In version 0.3.4, Bool32 and String32 were introduced as experimental features for testing purposes. Based on performance findings, these will be removed in upcoming releases. Only Int32 and Float32 will remain as valid 32‑bit types.

Please avoid using Bool32 and String32 in new code, and migrate existing projects to the standard Bool and String types for forward compatibility.

---

Upgrading from v0.3.4

Existing .dpn files will compile as before with no changes required. The new flags and void keyword are purely additive — nothing has been removed or renamed.

To try JavaScript compilation on an existing file:

dorpn <yourfile.dpn> -js
 #or
dorpn <yourfile.dpn> --Javs

---

Dorpn is an independent compiled language project — built from scratch, Join us on new community server on Discord to help us grow.

Dorpn v0.3.4 (Windows)

Dorpn Language — Changelog

All notable changes to the Dorpn programming language are documented here.

---

version - 0.3.4

🎯 Highlights

This release brings first-class 32-bit primitive type support to Dorpn, giving developers finer control over memory representation. A round of bug fixes also improves overall runtime stability.

---

✨ New Features

32-Bit Type System

Dorpn now introduces explicit 32-bit variants for all core primitive types:

Type	Description
Int32	32-bit signed integer
Float32	32-bit floating point number
String32	32-bit aligned string type
Bool32	32-bit boolean value

Note: The Bool32 and String32 are experimental feature only.

---

These types lay the groundwork for future low-level and systems-oriented features in Dorpn, and give you more precise control over how your data is represented at runtime.

Example usage in Dorpn:

tag x: Int32 = 100
Const pi: Float32 = 3.14
tag flag: Bool32 = flip
tag name: String32 = "Dorpn"

📦 Installation

Download the binary from the release assets below and you're ready to go.

⚠ Ensure you have GCC in your system path. Currently dorpn requires GCC to compile the code.

---

🐛 Bug Fixes

• Various minor bug fixes and internal improvements for better runtime stability.

Syntax highlighting

• Dorpn haves it's own extension for VsCode Editor.
• Download Extension from here.

---

🗺️ Roadmap — What's Coming Next

Here's a look at what's actively being worked on for future Dorpn releases:

[v0.4.0] — In Development

JavaScript Compilation Target

Dorpn will support compiling .dpn source files down to JavaScript via two new compiler flags:

• -js — Short flag to enable JavaScript as the compilation target
• --Javs — Long flag equivalent for the same JavaScript target

This will allow Dorpn code to be transpiled and executed in any JavaScript runtime, including browsers and Node.js — the first step toward Dorpn becoming a true multi-target language.

---

The Dorpn language is evolving fast. Stay tuned for updates, and thank you for being part of the journey.

---

Dorpn v0.3.3 (Windows)

🚀 Dorpn Language v0.3.3

We are pleased to announce the release of Dorpn v0.3.3. This update focuses on enhancing the developer workflow with new compiler utility flags and expanding the capabilities of the standard library for improved data handling.

These improvements aim to provide greater control over the compilation process and more flexibility when working with file I/O and string manipulation.

✨ Key Features & Improvements

🛠️ Compiler Workflow Enhancements

Three new command-line flags have been introduced to improve build management and debugging:

• -t / --time: Displays the total compilation duration. This allows developers to monitor overall build speed and track performance trends across versions.
• -ch / --cache: Provides the ability to clear the compiler cache manually. This ensures clean builds when troubleshooting cached dependency issues.
• --out <path>: Allows users to specify a custom output directory or file path for the generated binaries, offering better project organization.
  Note: Ensure the directory is already created .

📚 Standard Library Updates

• Enhanced .size() Method: The built-in .size() method has been upgraded to support unit arguments for file objects.
  • Default Behavior: Returns size in bytes (backward compatible).
  • New Functionality: Accepts string arguments such as "kb", "mb", "gb", "tb", to automatically convert and return the file size in the specified unit.
  • Example: print(file.size("mb")) returns the file size in Megabytes.

📝 Usage Examples

Compile and Run with Time Stats:

dorpn demo.dpn --run --time
dorpn demo.dpn -r -t

Clear Cache and Compile:

dorpn demo.dpn --cache
dorpn demo.dpn -ch

Specify Output Path:

dorpn demo.dpn --out ./build/my_app   #Assumes directory is created

File Size Conversion:

Const file : String = Onload("path/of/file")
print(file.size())      -- Returns bytes (default)
print(file.size("kb/mb/gb/tb"))  -- Returns size in specified unit.

📥 Installation

Windows Users:
Download the .exe installer from the Assets section below. The installer will automatically configure the system PATH, allowing you to run dorpn commands from any terminal window.

🐛 Bug Fixes & Stability

• General stability improvements to the compiler backend.
• Minor optimizations in string handling and memory management.
• Improved error messaging for invalid compiler flags.

🤝 Feedback & Support

We encourage the community to test these new features. If you encounter any issues or have suggestions for future releases, please open an issue on the GitHub tracker or join the discussion on our official discord server

Thank you for using Dorpn.

Dorpn v0.3.2 (Windows)

Dorpn v0.3.2 – Improved and Optimized

Overview

This release focuses on improving the clarity, reliability, and maintainability of the Dorpn language toolchain. By refining how code is generated and strengthening semantic validation, developers can expect a smoother workflow and more predictable outputs.

Highlights

• Refined Code Generation

  • Generated C files now only include the main logic from .dpn sources.
  • Helper functions have been moved into dedicated runtime C libraries, ensuring cleaner separation of concerns and easier maintenance.

• Improved Semantics

  • Semantic error handling has been strengthened.
  • Provides clearer diagnostics and stronger safeguards against invalid constructs, reducing debugging time and improving developer confidence.

• Case-Sensitive Constants

  • Constants Const are now strictly case-sensitive, aligning with industry standards and preventing unintended behavior.

• Stability Updates

  • Multiple minor fixes enhance overall stability, performance, and developer experience.

Developer Impact

With this release, developers benefit from:

• Cleaner and more predictable generated C files.
• Stronger semantic validation that reduces hidden errors.
• A runtime structure that is easier to extend and maintain.
• Improved consistency in constant handling.

Summary

Version 0.3.2 delivers a more professional and reliable development experience. By separating runtime helpers, strengthening semantics, and refining code generation, this update enhances both productivity and long-term maintainability for projects built with Dorpn.

Dorpn Programming Language v0.3.0 (Windows)

Dorpn v0.3.0 - First Public Release

Dorpn is a simple, beginner-friendly programming language designed to make coding accessible and enjoyable. This release packages everything you need to start coding in Dorpn right away - no separate compiler setup required!

📥 Download & Install

1. Download dorpn-setup-0.3.0.exe
2. Run the installer (admin rights recommended)
3. Select installation options:
   • ✓ Add Dorpn to system PATH
   • ✓ Create desktop shortcut (optional)
4. Click "Install" and you're ready!

Extention for Syntax Highlighting

Available on Visual Studio Code .
Dorpn Language Extension for VS Code

Verify Installation

Open Command Prompt and type:

dorpn --version