<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Ovie lang</title>
    <description>The latest articles on DEV Community by Ovie lang (@ovielang).</description>
    <link>https://dev.to/ovielang</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4239719%2F4d7c2249-54e8-469d-a321-3c0dee2ad17b.jpg</url>
      <title>DEV Community: Ovie lang</title>
      <link>https://dev.to/ovielang</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/ovielang"/>
    <language>en</language>
    <item>
      <title>Introducing Ovie Lang: Systems Programming Power with Developer-Friendly Abstractions</title>
      <dc:creator>Ovie lang</dc:creator>
      <pubDate>Tue, 17 Nov 2026 00:56:53 +0000</pubDate>
      <link>https://dev.to/ovielang/introducing-ovie-lang-systems-programming-power-with-developer-friendly-abstractions-2hc</link>
      <guid>https://dev.to/ovielang/introducing-ovie-lang-systems-programming-power-with-developer-friendly-abstractions-2hc</guid>
      <description>&lt;p&gt;We’re proud to introduce &lt;strong&gt;Ovie&lt;/strong&gt;, a self-hosted systems programming language designed to give developers the power of low-level control without forcing them to give up readability and productivity.&lt;/p&gt;

&lt;p&gt;Ovie sits in the space between traditional systems languages and modern high-level ones. It offers direct memory management, predictable performance, and hardware-level capabilities, while presenting a clean, expressive syntax that feels natural to write and reason about.&lt;/p&gt;

&lt;h3&gt;
  
  
  A Language with Its Own Identity
&lt;/h3&gt;

&lt;p&gt;Ovie doesn’t try to look exactly like C, Rust, or Python. It introduces its own clear vocabulary for everyday programming tasks:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;oya name = "Shedrack"
oya language = "Ovie"

mut age = 31

seeAm "Hello, " + name
seeAm language
seeAm age
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Here’s what the keywords mean:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;oya&lt;/code&gt; — immutable declaration (think “this value is fixed”)&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;mut&lt;/code&gt; — mutable declaration&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;seeAm&lt;/code&gt; — output with a newline&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;print&lt;/code&gt; — output without a newline&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The result is code that reads almost like a clear statement of intent.&lt;/p&gt;

&lt;h3&gt;
  
  
  Two Compilers, One Language
&lt;/h3&gt;

&lt;p&gt;Ovie ships with two compiler implementations that both understand the same &lt;code&gt;.ov&lt;/code&gt; source files:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;oviec&lt;/strong&gt; — the Rust-based reference compiler&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;oviev&lt;/strong&gt; — the self-hosted compiler written entirely in Ovie&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;You can run a program with either:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;oviec run hello.ov   &lt;span class="c"&gt;# Rust implementation&lt;/span&gt;
oviev run hello.ov   &lt;span class="c"&gt;# Self-hosted Ovie compiler&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Having a working self-hosted compiler is an important milestone. It means the language is mature enough to implement itself, and it gives the project greater long-term independence.&lt;/p&gt;

&lt;h3&gt;
  
  
  Meet Aproko — Your Built-in Coding Companion
&lt;/h3&gt;

&lt;p&gt;Every time you run code with &lt;code&gt;oviec&lt;/code&gt;, &lt;strong&gt;Aproko&lt;/strong&gt; is there.&lt;/p&gt;

&lt;p&gt;Aproko (an Urhobo word) is Ovie’s built-in analysis engine. It:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Catches invalid or suspicious keywords&lt;/li&gt;
&lt;li&gt;Explains runtime errors in plain language&lt;/li&gt;
&lt;li&gt;Gently teaches best practices as you write code&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;It’s like having a knowledgeable mentor looking over your shoulder — helpful without being noisy.&lt;/p&gt;

&lt;h3&gt;
  
  
  Installation (One Command)
&lt;/h3&gt;

&lt;p&gt;Getting started is intentionally simple.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Windows (PowerShell as Administrator):&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="n"&gt;iwr&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="n"&gt;useb&lt;/span&gt; &lt;span class="n"&gt;https&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;//&lt;/span&gt;&lt;span class="n"&gt;raw&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;githubusercontent&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;com&lt;/span&gt;&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="nc"&gt;Ovie&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Lang&lt;/span&gt;&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="n"&gt;ovie&lt;/span&gt;&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="n"&gt;main&lt;/span&gt;&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="n"&gt;easy&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="n"&gt;windows&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="n"&gt;install&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;ps1&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="n"&gt;iex&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Linux:&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;curl -sSL https://raw.githubusercontent.com/Ovie-Lang/ovie/main/easy-linux-install.sh &lt;span class="o"&gt;|&lt;/span&gt; bash
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;macOS:&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;curl -sSL https://raw.githubusercontent.com/Ovie-Lang/ovie/main/easy-macos-install.sh &lt;span class="o"&gt;|&lt;/span&gt; bash
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Or build from source:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git clone https://github.com/Ovie-Lang/ovie.git
&lt;span class="nb"&gt;cd&lt;/span&gt; ovie
cargo build --release --bin oviec
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then verify:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;oviec --version    &lt;span class="c"&gt;# Ovie Lang 1.0&lt;/span&gt;
oviev --version    &lt;span class="c"&gt;# Ovie Lang 1.0&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Why Ovie Exists
&lt;/h3&gt;

&lt;p&gt;Many modern tools quietly assume constant internet access, complex toolchains, and opaque behaviour. Ovie takes a different path:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Offline-first&lt;/strong&gt; by design&lt;/li&gt;
&lt;li&gt;Deterministic behaviour&lt;/li&gt;
&lt;li&gt;Explicit control where it matters&lt;/li&gt;
&lt;li&gt;Clear error messages&lt;/li&gt;
&lt;li&gt;A focus on long-term maintainability&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;It is aimed at developers building system tools, command-line applications, backend services, and performance-sensitive programs who still want an enjoyable, readable development experience.&lt;/p&gt;

&lt;h3&gt;
  
  
  The Official Project
&lt;/h3&gt;

&lt;p&gt;Ovie Lang is the official organisation for the language, its source code, documentation, releases, and community.&lt;/p&gt;

&lt;p&gt;The project is developed under &lt;strong&gt;Nashedy Ltd&lt;/strong&gt; and released under the MIT License.&lt;/p&gt;

&lt;h3&gt;
  
  
  Get Started Today
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;GitHub repository&lt;/strong&gt;: &lt;a href="https://github.com/Ovie-Lang/ovie" rel="noopener noreferrer"&gt;https://github.com/Ovie-Lang/ovie&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Documentation&lt;/strong&gt;: Getting Started, Language Guide, The Ovie Book, Aproko Guide, and Tutorials are all available in the repo&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;X/Twitter&lt;/strong&gt;: &lt;a href="https://x.com/Ovielang" rel="noopener noreferrer"&gt;@Ovielang&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;We believe systems programming can be both powerful &lt;em&gt;and&lt;/em&gt; approachable. Ovie is our attempt to prove it.&lt;/p&gt;

&lt;p&gt;Clone the repo, run your first program, and let us know what you build.&lt;/p&gt;

&lt;p&gt;Welcome to Ovie.&lt;/p&gt;

&lt;p&gt;The Ovie Lang Team&lt;/p&gt;

</description>
      <category>development</category>
      <category>programming</category>
      <category>softwaredevelopment</category>
    </item>
    <item>
      <title>Ovie lang in Southern Kaduna</title>
      <dc:creator>Ovie lang</dc:creator>
      <pubDate>Tue, 17 Nov 2026 00:42:41 +0000</pubDate>
      <link>https://dev.to/ovielang/ovie-lang-in-southern-kaduna-34lg</link>
      <guid>https://dev.to/ovielang/ovie-lang-in-southern-kaduna-34lg</guid>
      <description>&lt;p&gt;A practical guide to the Ovie programming language. Written for developers in Southern Kaduna and everywhere else.&lt;/p&gt;

&lt;p&gt;About This Book&lt;br&gt;
This book teaches Ovie from first principles. You will learn by building real programs. Every example runs. Every concept is explained in plain language.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/Ovie-Lang/ovie/blob/main/docs%2Fbook%2Fovie-in-southern-kaduna%2FREADME.md" rel="noopener noreferrer"&gt;https://github.com/Ovie-Lang/ovie/blob/main/docs%2Fbook%2Fovie-in-southern-kaduna%2FREADME.md&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Ovie is a systems programming language with natural syntax. It was built for developers who want low-level control without fighting the language to get it.&lt;/p&gt;

&lt;p&gt;The two keywords you need to know before anything else:&lt;/p&gt;

&lt;p&gt;oya name = "Ovie"    // immutable — this never changes&lt;br&gt;
mut count = 0        // mutable — this can be updated&lt;br&gt;
Chapters&lt;br&gt;
Chapter Title   What You Learn&lt;br&gt;
1   Introduction    What Ovie is, oya vs mut, Aproko, oviev self-hosted compiler&lt;br&gt;
2   Installation    Install on Windows, Linux, macOS, or build from source&lt;br&gt;
3   Language Fundamentals   oya, mut, fn, if, loops, structs, enums, match&lt;br&gt;
4   Module System   use, import, export, packages, ovie.toml&lt;br&gt;
5   Standard Library    All 11 stdlib modules with examples&lt;br&gt;
6   Aproko  Built-in analyser, best practices, error explanations&lt;br&gt;
7   Production Programs Error handling, structs, real programs&lt;br&gt;
8   Testing Unit tests, property tests, std::testing&lt;br&gt;
9   Performance Profiling, benchmarking, optimization&lt;br&gt;
10  Deployment  Packaging, containers, cross-platform&lt;br&gt;
11  Community   Contributing, GitHub, Discord&lt;br&gt;
12  Stories Real programs built with Ovie&lt;br&gt;
Quick Start&lt;br&gt;
Install Ovie, then run:&lt;/p&gt;

&lt;p&gt;oya APP = "My first Ovie program"&lt;br&gt;
seeAm APP&lt;br&gt;
oviec run hello.ov&lt;br&gt;
Copyright&lt;br&gt;
Copyright (c) 2026 Nashedy Ltd. MIT License.&lt;/p&gt;

</description>
      <category>beginners</category>
      <category>programming</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>Ovie Language Fundamentals</title>
      <dc:creator>Ovie lang</dc:creator>
      <pubDate>Tue, 17 Nov 2026 00:40:58 +0000</pubDate>
      <link>https://dev.to/ovielang/ovie-language-fundamentals-4d0p</link>
      <guid>https://dev.to/ovielang/ovie-language-fundamentals-4d0p</guid>
      <description>&lt;p&gt;This chapter covers everything you need to write real Ovie programs. We start with the two most important keywords — oya and mut — and build up from there.&lt;/p&gt;

&lt;p&gt;Variables: oya vs mut&lt;br&gt;
Ovie has two ways to declare a variable.&lt;/p&gt;

&lt;p&gt;oya — immutable. Use this by default.&lt;/p&gt;

&lt;p&gt;oya name    = "Shedrack"&lt;br&gt;
oya version = 2.3&lt;br&gt;
oya active  = true&lt;br&gt;
Once you declare something with oya, its value is set. You cannot reassign it. This is not a limitation — it is a feature. When you read code later and see oya, you immediately know that value never changes anywhere in the program.&lt;/p&gt;

&lt;p&gt;mut — mutable. Use this when the value actually changes.&lt;/p&gt;

&lt;p&gt;mut counter = 0&lt;br&gt;
counter = counter + 1&lt;br&gt;
seeAm counter  // 1&lt;br&gt;
Side by side:&lt;/p&gt;

&lt;p&gt;oya MAX_SCORE  = 100      // fixed — never changes&lt;br&gt;
oya GAME_NAME  = "Ovie Runner"&lt;/p&gt;

&lt;p&gt;mut player_score = 0      // changes as the player plays&lt;br&gt;
mut lives        = 3&lt;/p&gt;

&lt;p&gt;player_score = player_score + 10&lt;br&gt;
lives = lives - 1&lt;/p&gt;

&lt;p&gt;seeAm player_score  // 10&lt;br&gt;
seeAm lives         // 2&lt;br&gt;
When to use which:&lt;/p&gt;

&lt;p&gt;App name, version, limits, error messages → oya&lt;br&gt;
Counters, accumulators, state that changes → mut&lt;br&gt;
When in doubt — start with oya. If the compiler complains you tried to reassign it, switch to mut.&lt;br&gt;
Types&lt;br&gt;
Ovie infers types. The core types you will use:&lt;/p&gt;

&lt;p&gt;Type    What it holds   Example&lt;br&gt;
Number  integers and decimals   42, 3.14&lt;br&gt;
String  text    "Hello"&lt;br&gt;
Boolean true or false   true, false&lt;br&gt;
Array   ordered list    [1, 2, 3]&lt;br&gt;
oya count    = 42&lt;br&gt;
oya pi       = 3.14&lt;br&gt;
oya greeting = "Hello"&lt;br&gt;
oya active   = true&lt;br&gt;
oya scores   = [10, 20, 30]&lt;br&gt;
You can add type annotations if you want to be explicit:&lt;/p&gt;

&lt;p&gt;oya name: String  = "Ovie"&lt;br&gt;
oya age:  Number  = 25&lt;br&gt;
mut flag: Boolean = false&lt;br&gt;
Functions&lt;br&gt;
fn add(a: Number, b: Number) -&amp;gt; Number {&lt;br&gt;
    return a + b&lt;br&gt;
}&lt;/p&gt;

&lt;p&gt;mut result = add(10, 20)&lt;br&gt;
seeAm result  // 30&lt;br&gt;
Functions with no return value:&lt;/p&gt;

&lt;p&gt;fn greet(name: String) {&lt;br&gt;
    seeAm "Hello, " + name&lt;br&gt;
}&lt;/p&gt;

&lt;p&gt;greet("Amina")  // Hello, Amina&lt;br&gt;
Using oya inside a function for fixed values:&lt;/p&gt;

&lt;p&gt;fn circle_area(radius: Number) -&amp;gt; Number {&lt;br&gt;
    oya PI = 3.14159&lt;br&gt;
    return PI * radius * radius&lt;br&gt;
}&lt;/p&gt;

&lt;p&gt;seeAm circle_area(5.0)  // 78.53975&lt;br&gt;
Output and Input&lt;br&gt;
Print a value:&lt;/p&gt;

&lt;p&gt;seeAm "Hello World"&lt;br&gt;
seeAm 42&lt;br&gt;
seeAm true&lt;br&gt;
Print without newline (for prompts):&lt;/p&gt;

&lt;p&gt;print("Enter your name: ")&lt;br&gt;
Read input from the user:&lt;/p&gt;

&lt;p&gt;print("What is your name? ")&lt;br&gt;
mut name = read_line()&lt;br&gt;
seeAm "Hello, " + name&lt;br&gt;
if / else&lt;br&gt;
mut score = 75&lt;/p&gt;

&lt;p&gt;if score &amp;gt;= 90 {&lt;br&gt;
    seeAm "Excellent"&lt;br&gt;
} else if score &amp;gt;= 60 {&lt;br&gt;
    seeAm "Good"&lt;br&gt;
} else {&lt;br&gt;
    seeAm "Keep going"&lt;br&gt;
}&lt;br&gt;
while&lt;br&gt;
mut count = 0&lt;br&gt;
while count &amp;lt; 5 {&lt;br&gt;
    seeAm count&lt;br&gt;
    count = count + 1&lt;br&gt;
}&lt;br&gt;
for&lt;br&gt;
for i in 0..5 {&lt;br&gt;
    seeAm i   // prints 0 1 2 3 4&lt;br&gt;
}&lt;br&gt;
break and continue&lt;br&gt;
mut n = 0&lt;br&gt;
while true {&lt;br&gt;
    n = n + 1&lt;br&gt;
    if n == 3 { continue }  // skip 3&lt;br&gt;
    if n == 6 { break }     // stop at 6&lt;br&gt;
    seeAm n&lt;br&gt;
}&lt;br&gt;
// prints 1 2 4 5&lt;br&gt;
struct&lt;br&gt;
struct Person {&lt;br&gt;
    name: String,&lt;br&gt;
    age: Number,&lt;br&gt;
}&lt;/p&gt;

&lt;p&gt;mut p = Person { name: "Amina", age: 28 }&lt;br&gt;
seeAm p.name   // Amina&lt;br&gt;
seeAm p.age    // 28&lt;br&gt;
enum&lt;br&gt;
enum Direction { North, South, East, West }&lt;/p&gt;

&lt;p&gt;mut heading = Direction.North&lt;br&gt;
seeAm heading   // North&lt;br&gt;
match&lt;br&gt;
enum Status { Active, Inactive, Pending }&lt;br&gt;
mut s = Status.Active&lt;/p&gt;

&lt;p&gt;match s {&lt;br&gt;
    Status.Active   =&amp;gt; seeAm "Running"&lt;br&gt;
    Status.Inactive =&amp;gt; seeAm "Stopped"&lt;br&gt;
    Status.Pending  =&amp;gt; seeAm "Waiting"&lt;br&gt;
}&lt;br&gt;
Putting it Together&lt;br&gt;
Here is a small program that uses everything in this chapter:&lt;/p&gt;

&lt;p&gt;// Config — all fixed, so oya&lt;br&gt;
oya APP   = "Grade Calculator"&lt;br&gt;
oya LIMIT = 100&lt;/p&gt;

&lt;p&gt;fn grade(score: Number) -&amp;gt; String {&lt;br&gt;
    if score &amp;gt;= 90 { return "A" }&lt;br&gt;
    if score &amp;gt;= 80 { return "B" }&lt;br&gt;
    if score &amp;gt;= 70 { return "C" }&lt;br&gt;
    if score &amp;gt;= 60 { return "D" }&lt;br&gt;
    return "F"&lt;br&gt;
}&lt;/p&gt;

&lt;p&gt;seeAm APP&lt;br&gt;
seeAm "Enter scores (type 0 to finish):"&lt;/p&gt;

&lt;p&gt;mut total = 0&lt;br&gt;
mut count = 0&lt;/p&gt;

&lt;p&gt;mut running = true&lt;br&gt;
while running {&lt;br&gt;
    print("&amp;gt; ")&lt;br&gt;
    mut input = read_line()&lt;br&gt;
    mut score = string_to_number(string_trim(input))&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;if score == 0 {
    running = false
} else {
    total = total + score
    count = count + 1
    seeAm "Grade: " + grade(score)
}
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;}&lt;/p&gt;

&lt;p&gt;if count &amp;gt; 0 {&lt;br&gt;
    mut avg = total / count&lt;br&gt;
    seeAm "Average: " + number_to_string(avg)&lt;br&gt;
    seeAm "Overall: " + grade(avg)&lt;br&gt;
} else {&lt;br&gt;
    seeAm "No scores entered."&lt;br&gt;
}&lt;br&gt;
Notice: APP, LIMIT and PI use oya because they never change. total, count, running use mut because they are updated in the loop.&lt;/p&gt;

&lt;p&gt;Built-in String and Number Functions&lt;br&gt;
Function    What it does&lt;br&gt;
string_length(s)    length of a string&lt;br&gt;
string_trim(s)  remove leading/trailing whitespace&lt;br&gt;
string_split(s, sep)    split string into array by separator&lt;br&gt;
string_to_number(s) convert "42" to 42&lt;br&gt;
number_to_string(n) convert 42 to "42"&lt;br&gt;
array_length(arr)   number of items in array&lt;br&gt;
array_get(arr, i)   get item at index i&lt;br&gt;
string_contains(s, sub) true if s contains sub&lt;br&gt;
string_replace(s, from, to) replace text in string&lt;/p&gt;

</description>
      <category>beginners</category>
      <category>coding</category>
      <category>programming</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>Build a Calculator in Ovie Lang, Learning the oya Keyword</title>
      <dc:creator>Ovie lang</dc:creator>
      <pubDate>Tue, 17 Nov 2026 00:38:20 +0000</pubDate>
      <link>https://dev.to/ovielang/build-a-calculator-in-ovie-lang-learning-the-oya-keyword-c42</link>
      <guid>https://dev.to/ovielang/build-a-calculator-in-ovie-lang-learning-the-oya-keyword-c42</guid>
      <description>&lt;p&gt;Ovie is a systems programming language that borrows natural language patterns. One of the keywords that sets it apart is oya — Ovie's word for immutable variable declaration.&lt;/p&gt;

&lt;p&gt;This tutorial builds an interactive calculator step by step, introducing oya as we go.&lt;/p&gt;

&lt;p&gt;Setup&lt;br&gt;
You need Ovie installed. On Windows:&lt;/p&gt;

&lt;h1&gt;
  
  
  Run as Administrator
&lt;/h1&gt;

&lt;p&gt;iwr -useb &lt;a href="https://raw.githubusercontent.com/Ovie-Lang/ovie/main/easy-windows-install.ps1" rel="noopener noreferrer"&gt;https://raw.githubusercontent.com/Ovie-Lang/ovie/main/easy-windows-install.ps1&lt;/a&gt; | iex&lt;br&gt;
Or build from source:&lt;/p&gt;

&lt;p&gt;git clone &lt;a href="https://github.com/Ovie-Lang/ovie.git" rel="noopener noreferrer"&gt;https://github.com/Ovie-Lang/ovie.git&lt;/a&gt;&lt;br&gt;
cd ovie&lt;br&gt;
cargo build --release --bin oviec&lt;br&gt;
Verify:&lt;/p&gt;

&lt;p&gt;oviec --version&lt;br&gt;
Step 1: Print something&lt;br&gt;
Create calculator.ov:&lt;/p&gt;

&lt;p&gt;seeAm "OVIE CALCULATOR"&lt;br&gt;
Run it:&lt;/p&gt;

&lt;p&gt;oviec run calculator.ov&lt;br&gt;
seeAm is Ovie's print — from Nigerian Pidgin English for "see for yourself."&lt;/p&gt;

&lt;p&gt;Step 2: Add oya constants&lt;br&gt;
Now let us add the fixed strings our calculator needs. These never change — so they belong to oya:&lt;/p&gt;

&lt;p&gt;oya APP_NAME  = "OVIE CALCULATOR v1.0"&lt;br&gt;
oya BORDER    = "==============================="&lt;br&gt;
oya QUIT_MSG  = "Type q to quit"&lt;br&gt;
oya BYE_MSG   = "Bye!"&lt;br&gt;
oya PROMPT    = "&amp;gt; "&lt;/p&gt;

&lt;p&gt;seeAm BORDER&lt;br&gt;
seeAm "   " + APP_NAME&lt;br&gt;
seeAm BORDER&lt;br&gt;
seeAm QUIT_MSG&lt;br&gt;
oya says: this value is fixed. If you try to reassign it later, Ovie stops you. That is the point — it makes intent clear.&lt;/p&gt;

&lt;p&gt;Step 3: Add mut for things that change&lt;br&gt;
mut is for values that will be reassigned:&lt;/p&gt;

&lt;p&gt;mut running = true&lt;br&gt;
The calculator loop will flip running to false when the user types q.&lt;/p&gt;

&lt;p&gt;Step 4: The calculate function&lt;br&gt;
fn calculate(a: Number, op: String, b: Number) -&amp;gt; String {&lt;br&gt;
    oya DIV_ZERO = "Error: Division by zero"&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;if op == "+" { return number_to_string(a + b) }
if op == "-" { return number_to_string(a - b) }
if op == "*" { return number_to_string(a * b) }
if op == "/" {
    if b == 0 { return DIV_ZERO }
    return number_to_string(a / b)
}
if op == "%" {
    if b == 0 { return DIV_ZERO }
    return number_to_string(a % b)
}
return "Error: Unknown operator"
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;}&lt;br&gt;
Notice DIV_ZERO inside the function — it is oya because it is a fixed error message.&lt;/p&gt;

&lt;p&gt;Step 5: The input loop&lt;br&gt;
while running {&lt;br&gt;
    print(PROMPT)&lt;br&gt;
    mut input = read_line()&lt;br&gt;
    mut trimmed = string_trim(input)&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;if trimmed == "q" {
    seeAm BYE_MSG
    running = false
} else if trimmed == "" {
    // skip empty lines
} else {
    mut parts = string_split(trimmed, " ")
    if array_length(parts) != 3 {
        seeAm "Usage: &amp;lt;number&amp;gt; &amp;lt;op&amp;gt; &amp;lt;number&amp;gt;   e.g.  10 + 5"
    } else {
        mut a_str  = array_get(parts, 0)
        mut op     = array_get(parts, 1)
        mut b_str  = array_get(parts, 2)
        mut a      = string_to_number(a_str)
        mut b      = string_to_number(b_str)
        mut result = calculate(a, op, b)
        seeAm "= " + result
    }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;}&lt;br&gt;
Full Program&lt;br&gt;
oya APP_NAME   = "OVIE CALCULATOR v1.0"&lt;br&gt;
oya BORDER     = "==============================="&lt;br&gt;
oya QUIT_CMD   = "q"&lt;br&gt;
oya USAGE_MSG  = "Usage:      e.g.  10 + 5"&lt;br&gt;
oya BYE_MSG    = "Bye!"&lt;br&gt;
oya PROMPT     = "&amp;gt; "&lt;br&gt;
oya DIV_ZERO   = "Error: Division by zero"&lt;br&gt;
oya UNKNOWN_OP = "Error: Unknown operator"&lt;/p&gt;

&lt;p&gt;fn calculate(a: Number, op: String, b: Number) -&amp;gt; String {&lt;br&gt;
    if op == "+" { return number_to_string(a + b) }&lt;br&gt;
    if op == "-" { return number_to_string(a - b) }&lt;br&gt;
    if op == "*" { return number_to_string(a * b) }&lt;br&gt;
    if op == "/" {&lt;br&gt;
        if b == 0 { return DIV_ZERO }&lt;br&gt;
        return number_to_string(a / b)&lt;br&gt;
    }&lt;br&gt;
    if op == "%" {&lt;br&gt;
        if b == 0 { return DIV_ZERO }&lt;br&gt;
        return number_to_string(a % b)&lt;br&gt;
    }&lt;br&gt;
    return UNKNOWN_OP&lt;br&gt;
}&lt;/p&gt;

&lt;p&gt;seeAm BORDER&lt;br&gt;
seeAm "   " + APP_NAME&lt;br&gt;
seeAm BORDER&lt;br&gt;
seeAm "Enter:   "&lt;br&gt;
seeAm "Operators:  + - * / %"&lt;br&gt;
seeAm "Type q to quit"&lt;br&gt;
seeAm BORDER&lt;br&gt;
seeAm ""&lt;/p&gt;

&lt;p&gt;mut running = true&lt;/p&gt;

&lt;p&gt;while running {&lt;br&gt;
    print(PROMPT)&lt;br&gt;
    mut input = read_line()&lt;br&gt;
    mut trimmed = string_trim(input)&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;if trimmed == QUIT_CMD {
    seeAm BYE_MSG
    running = false
} else if trimmed == "" {
    // skip
} else {
    mut parts = string_split(trimmed, " ")
    if array_length(parts) != 3 {
        seeAm USAGE_MSG
    } else {
        mut a      = string_to_number(array_get(parts, 0))
        mut op     = array_get(parts, 1)
        mut b      = string_to_number(array_get(parts, 2))
        mut result = calculate(a, op, b)
        seeAm "= " + result
    }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;}&lt;br&gt;
Try it&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;10 + 5&lt;br&gt;
= 15&lt;br&gt;
9 * 9&lt;br&gt;
= 81&lt;br&gt;
17 % 5&lt;br&gt;
= 2&lt;br&gt;
10 / 0&lt;br&gt;
= Error: Division by zero&lt;br&gt;
q&lt;br&gt;
Bye!&lt;br&gt;
What we learned&lt;br&gt;
oya declares immutable values — use it for anything that does not change&lt;br&gt;
mut declares mutable values — use it for loop state and things that update&lt;br&gt;
seeAm prints to the terminal&lt;br&gt;
print() prints without a newline (for prompts)&lt;br&gt;
read_line() reads input from the user&lt;br&gt;
string_split, string_trim, string_to_number, number_to_string are built-in string utilities&lt;/p&gt;
&lt;/blockquote&gt;

</description>
      <category>beginners</category>
      <category>learning</category>
      <category>programming</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>Creating Packages Ovie Lang</title>
      <dc:creator>Ovie lang</dc:creator>
      <pubDate>Tue, 17 Nov 2026 00:36:07 +0000</pubDate>
      <link>https://dev.to/ovielang/creating-packages-ovie-lang-1f9k</link>
      <guid>https://dev.to/ovielang/creating-packages-ovie-lang-1f9k</guid>
      <description>&lt;p&gt;This tutorial shows you how to create a reusable Ovie package that others can depend on.&lt;/p&gt;

&lt;p&gt;What is a Package?&lt;br&gt;
A package is a directory with an ovie.toml manifest and a src/mod.ov entry point. Other projects add it as a dependency and import from it using use package_name::symbol.&lt;/p&gt;

&lt;p&gt;Step 1: Initialize the Package&lt;br&gt;
ovie init my-math-utils&lt;br&gt;
cd my-math-utils&lt;br&gt;
Edit ovie.toml to describe your package:&lt;/p&gt;

&lt;p&gt;[package]&lt;br&gt;
name = "my-math-utils"&lt;br&gt;
version = "0.1.0"&lt;br&gt;
description = "Useful math utilities for Ovie"&lt;br&gt;
authors = ["Your Name &lt;a href="mailto:you@example.com"&gt;you@example.com&lt;/a&gt;"]&lt;br&gt;
license = "MIT"&lt;/p&gt;

&lt;p&gt;[dependencies]&lt;/p&gt;
&lt;h1&gt;
  
  
  no external dependencies yet
&lt;/h1&gt;

&lt;p&gt;[build]&lt;br&gt;
entry = "src/mod.ov"&lt;br&gt;
Step 2: Write the Public API&lt;br&gt;
Create src/mod.ov — the package entry point that re-exports your public API:&lt;/p&gt;

&lt;p&gt;/// my-math-utils — Useful math utilities&lt;br&gt;
///&lt;br&gt;
/// # Examples&lt;br&gt;
///&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/// use my-math-utils::{clamp, lerp, map_range}
/// ```



export use ./clamp::{clamp, clamp_f};
export use ./interpolate::{lerp, lerp_f, map_range};
export use ./stats::{mean, median, variance};
Step 3: Implement the Modules
Create src/clamp.ov:

/// Clamp an integer value between min and max
/// # Parameters
/// - value: The value to clamp
/// - min: Minimum allowed value
/// - max: Maximum allowed value
/// # Returns
/// value clamped to [min, max]
/// # Examples
///

 ```ovie
/// mut x = clamp(15, 0, 10)  // 10
/// mut y = clamp(-5, 0, 10)  // 0
/// mut z = clamp(5, 0, 10)   // 5
/// ```


export fn clamp(value: Number, min: Number, max: Number) -&amp;gt; Number {
    if value &amp;lt; min { return min }
    if value &amp;gt; max { return max }
    return value
}

/// Clamp a float value between min and max
/// # Parameters
/// - value: The float value to clamp
/// - min: Minimum allowed value
/// - max: Maximum allowed value
/// # Returns
/// value clamped to [min, max]
/// # Examples
///

 ```ovie
/// mut x = clamp_f(1.5, 0.0, 1.0)  // 1.0
/// ```


export fn clamp_f(value: Float, min: Float, max: Float) -&amp;gt; Float {
    if value &amp;lt; min { return min }
    if value &amp;gt; max { return max }
    return value
}
Create src/interpolate.ov:

/// Linear interpolation between two values
/// # Parameters
/// - a: Start value
/// - b: End value
/// - t: Interpolation factor (0.0 = a, 1.0 = b)
/// # Returns
/// Interpolated value
/// # Examples
///

 ```ovie
/// mut mid = lerp(0.0, 10.0, 0.5)  // 5.0
/// ```


export fn lerp(a: Float, b: Float, t: Float) -&amp;gt; Float {
    return a + (b - a) * t
}

/// Linear interpolation for integers
/// # Parameters
/// - a: Start value
/// - b: End value
/// - t: Interpolation factor (0.0 to 1.0)
/// # Returns
/// Interpolated integer value
/// # Examples
///

 ```ovie
/// mut mid = lerp_f(0, 100, 0.5)  // 50
/// ```


export fn lerp_f(a: Number, b: Number, t: Float) -&amp;gt; Number {
    return a + ((b - a) as Float * t) as Number
}

/// Map a value from one range to another
/// # Parameters
/// - value: Input value
/// - in_min: Input range minimum
/// - in_max: Input range maximum
/// - out_min: Output range minimum
/// - out_max: Output range maximum
/// # Returns
/// Value mapped to output range
/// # Examples
///

 ```ovie
/// mut mapped = map_range(5.0, 0.0, 10.0, 0.0, 100.0)  // 50.0
/// ```


export fn map_range(value: Float, in_min: Float, in_max: Float, out_min: Float, out_max: Float) -&amp;gt; Float {
    return out_min + (value - in_min) / (in_max - in_min) * (out_max - out_min)
}
Step 4: Validate Documentation
ovie doc check
Fix any missing doc comments before publishing.

Step 5: Generate Documentation
ovie doc --format html
Documentation is generated in docs/output/. Review it to make sure everything looks correct.

Step 6: Use Your Package Locally
In another project, add your package as a path dependency:

ovie add my-math-utils --path ../my-math-utils
This adds to ovie.toml:

[dependencies]
my-math-utils = { path = "../my-math-utils" }
Then import and use it:

use my-math-utils::{clamp, lerp, map_range}

fn main() {
    mut health = clamp(150, 0, 100)
    seeAm("Health: " + health)  // Health: 100

    mut progress = lerp(0.0, 1.0, 0.75)
    seeAm("Progress: " + progress)  // Progress: 0.75

    mut screen_x = map_range(0.5, 0.0, 1.0, 0.0, 1920.0)
    seeAm("Screen X: " + screen_x)  // Screen X: 960.0
}

main()
Package Structure Summary
my-math-utils/
├── ovie.toml          # package manifest
├── src/
│   ├── mod.ov         # public API entry point (re-exports)
│   ├── clamp.ov       # clamp implementation
│   ├── interpolate.ov # interpolation implementation
│   └── stats.ov       # statistics implementation
└── tests/
    └── test_clamp.ov  # tests
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

</description>
      <category>coding</category>
      <category>programming</category>
      <category>softwaredevelopment</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>Beginner Guide: The oya Keyword in Ovie</title>
      <dc:creator>Ovie lang</dc:creator>
      <pubDate>Tue, 17 Nov 2026 00:34:27 +0000</pubDate>
      <link>https://dev.to/ovielang/beginner-guide-the-oya-keyword-in-ovie-2l50</link>
      <guid>https://dev.to/ovielang/beginner-guide-the-oya-keyword-in-ovie-2l50</guid>
      <description>&lt;p&gt;oya is Ovie is immutable declaration keyword. This guide explains what it means, why it matters, and how to use it.&lt;/p&gt;

&lt;p&gt;What "immutable" means in plain English&lt;br&gt;
Immutable means: once you set it, it stays set.&lt;/p&gt;

&lt;p&gt;Think of oya like writing something in permanent marker. mut is like writing in pencil — you can erase and rewrite it.&lt;/p&gt;

&lt;p&gt;oya city = "Lagos"    // written in permanent marker&lt;br&gt;
mut score = 0         // written in pencil&lt;br&gt;
If you try to change an oya variable:&lt;/p&gt;

&lt;p&gt;oya city = "Lagos"&lt;br&gt;
city = "Abuja"        // Ovie will stop you with an error&lt;br&gt;
That is a feature, not a bug. It tells you "this was not meant to change."&lt;/p&gt;

&lt;p&gt;Program 1: Hello with oya&lt;br&gt;
oya greeting = "Hello, Ovie!"&lt;br&gt;
oya author   = "Shedrack"&lt;/p&gt;

&lt;p&gt;seeAm greeting&lt;br&gt;
seeAm "Written by " + author&lt;br&gt;
Run:&lt;/p&gt;

&lt;p&gt;oviec run hello.ov&lt;br&gt;
Output:&lt;/p&gt;

&lt;p&gt;Hello, Ovie!&lt;br&gt;
Written by Shedrack&lt;br&gt;
Program 2: oya for configuration constants&lt;br&gt;
Real programs have config values that never change — version numbers, limits, app names. These belong to oya:&lt;/p&gt;

&lt;p&gt;oya APP_NAME    = "Student Register"&lt;br&gt;
oya MAX_SCORE   = 100&lt;br&gt;
oya PASS_SCORE  = 40&lt;br&gt;
oya SCHOOL_NAME = "Kaduna Polytechnic"&lt;/p&gt;

&lt;p&gt;seeAm APP_NAME + " — " + SCHOOL_NAME&lt;br&gt;
seeAm "Maximum score: " + number_to_string(MAX_SCORE)&lt;br&gt;
seeAm "Pass mark: " + number_to_string(PASS_SCORE)&lt;br&gt;
Program 3: Mixing oya and mut in a counter&lt;br&gt;
oya TARGET = 5        // the goal never changes&lt;br&gt;
mut count  = 0        // the count changes every loop&lt;/p&gt;

&lt;p&gt;seeAm "Counting to " + number_to_string(TARGET)&lt;/p&gt;

&lt;p&gt;while count &amp;lt; TARGET {&lt;br&gt;
    count = count + 1&lt;br&gt;
    seeAm count&lt;br&gt;
}&lt;/p&gt;

&lt;p&gt;seeAm "Done!"&lt;br&gt;
Output:&lt;/p&gt;

&lt;p&gt;Counting to 5&lt;br&gt;
1&lt;br&gt;
2&lt;br&gt;
3&lt;br&gt;
4&lt;br&gt;
5&lt;br&gt;
Done!&lt;br&gt;
Program 4: oya inside a function&lt;br&gt;
You can use oya inside a function for values that are fixed within that function:&lt;/p&gt;

&lt;p&gt;fn describe_temperature(temp: Number) -&amp;gt; String {&lt;br&gt;
    oya FREEZING = 0&lt;br&gt;
    oya COLD     = 15&lt;br&gt;
    oya WARM     = 25&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;if temp &amp;lt;= FREEZING { return "Freezing" }
if temp &amp;lt;= COLD     { return "Cold" }
if temp &amp;lt;= WARM     { return "Warm" }
return "Hot"
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;}&lt;/p&gt;

&lt;p&gt;seeAm describe_temperature(-5)   // Freezing&lt;br&gt;
seeAm describe_temperature(10)   // Cold&lt;br&gt;
seeAm describe_temperature(22)   // Warm&lt;br&gt;
seeAm describe_temperature(38)   // Hot&lt;br&gt;
Program 5: The Calculator — oya for all fixed strings&lt;br&gt;
This is the full calculator from the tutorial. Every fixed string uses oya. Only the loop state and user input use mut:&lt;/p&gt;

&lt;p&gt;oya APP_NAME   = "OVIE CALCULATOR v1.0"&lt;br&gt;
oya BORDER     = "==============================="&lt;br&gt;
oya QUIT_CMD   = "q"&lt;br&gt;
oya USAGE_MSG  = "Usage:      e.g.  10 + 5"&lt;br&gt;
oya BYE_MSG    = "Bye!"&lt;br&gt;
oya PROMPT     = "&amp;gt; "&lt;br&gt;
oya DIV_ZERO   = "Error: Division by zero"&lt;br&gt;
oya UNKNOWN_OP = "Error: Unknown operator"&lt;/p&gt;

&lt;p&gt;fn calculate(a: Number, op: String, b: Number) -&amp;gt; String {&lt;br&gt;
    if op == "+" { return number_to_string(a + b) }&lt;br&gt;
    if op == "-" { return number_to_string(a - b) }&lt;br&gt;
    if op == "*" { return number_to_string(a * b) }&lt;br&gt;
    if op == "/" {&lt;br&gt;
        if b == 0 { return DIV_ZERO }&lt;br&gt;
        return number_to_string(a / b)&lt;br&gt;
    }&lt;br&gt;
    if op == "%" {&lt;br&gt;
        if b == 0 { return DIV_ZERO }&lt;br&gt;
        return number_to_string(a % b)&lt;br&gt;
    }&lt;br&gt;
    return UNKNOWN_OP&lt;br&gt;
}&lt;/p&gt;

&lt;p&gt;seeAm BORDER&lt;br&gt;
seeAm "   " + APP_NAME&lt;br&gt;
seeAm BORDER&lt;br&gt;
seeAm ""&lt;/p&gt;

&lt;p&gt;mut running = true&lt;/p&gt;

&lt;p&gt;while running {&lt;br&gt;
    print(PROMPT)&lt;br&gt;
    mut input   = read_line()&lt;br&gt;
    mut trimmed = string_trim(input)&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;if trimmed == QUIT_CMD {
    seeAm BYE_MSG
    running = false
} else if trimmed == "" {
    // skip
} else {
    mut parts = string_split(trimmed, " ")
    if array_length(parts) != 3 {
        seeAm USAGE_MSG
    } else {
        mut a      = string_to_number(array_get(parts, 0))
        mut op     = array_get(parts, 1)
        mut b      = string_to_number(array_get(parts, 2))
        seeAm "= " + calculate(a, op, b)
    }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;}&lt;br&gt;
When to use oya vs mut&lt;br&gt;
Use oya when... Use mut when...&lt;br&gt;
The value never changes The value will be reassigned&lt;br&gt;
It is a constant (PI, MAX, VERSION) It is a counter or accumulator&lt;br&gt;
It is a fixed message or label  It holds user input&lt;br&gt;
It is config that should not drift  It is loop state&lt;br&gt;
You want the compiler to protect it You intentionally update it&lt;br&gt;
Default rule: start with oya. If you get a compiler error saying you tried to reassign it, change it to mut.&lt;/p&gt;

</description>
      <category>beginners</category>
      <category>coding</category>
      <category>programming</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>Aproko: Read Your Errors Like a Pro in Ovie</title>
      <dc:creator>Ovie lang</dc:creator>
      <pubDate>Tue, 17 Nov 2026 00:33:12 +0000</pubDate>
      <link>https://dev.to/ovielang/aproko-read-your-errors-like-a-pro-in-ovie-337l</link>
      <guid>https://dev.to/ovielang/aproko-read-your-errors-like-a-pro-in-ovie-337l</guid>
      <description>&lt;p&gt;Aproko is an Urhobo word — it means someone who notices everything and tells it straight. In Ovie, Aproko runs before every program and explains every error in plain language.&lt;/p&gt;

&lt;p&gt;How Aproko Works&lt;br&gt;
Every time you run oviec run file.ov, two things happen:&lt;/p&gt;

&lt;p&gt;Aproko pre-flight — scans source for bad patterns BEFORE execution&lt;br&gt;
Aproko explanation — if a runtime error occurs, shows the source line and explains it&lt;br&gt;
Error 1: Wrong keyword&lt;br&gt;
If you type 'see', 'var', 'let', 'def' — Aproko catches it immediately:&lt;/p&gt;

&lt;p&gt;see name = "Nigeria"&lt;br&gt;
seeAm name&lt;br&gt;
Aproko output (BEFORE the program runs):&lt;/p&gt;

&lt;p&gt;== Aproko =============================================&lt;br&gt;
  [error] line 1: 'see' is not an Ovie keyword&lt;/p&gt;

&lt;h1&gt;
  
  
      hint: oya see = value  or  mut see = value
&lt;/h1&gt;

&lt;p&gt;Aproko explanation (AFTER the runtime error):&lt;/p&gt;

&lt;p&gt;== Aproko Explanation ================================&lt;br&gt;
  Line 1: see name = "Nigeria"&lt;br&gt;
  Error: Undefined variable: see&lt;br&gt;
  What happened: 'see' is not an Ovie keyword.&lt;/p&gt;

&lt;h1&gt;
  
  
    Use oya (immutable) or mut (mutable). Try: oya name = value
&lt;/h1&gt;

&lt;p&gt;Fix:&lt;/p&gt;

&lt;p&gt;oya name = "Nigeria"   // immutable - use by default&lt;br&gt;
seeAm name&lt;br&gt;
Error 2: Variable not declared&lt;br&gt;
seeAm total_price&lt;br&gt;
Aproko says:&lt;/p&gt;

&lt;p&gt;What happened: Variable 'total_price' is not declared.&lt;br&gt;
Use: oya total_price = value  or  mut total_price = value&lt;br&gt;
Fix:&lt;/p&gt;

&lt;p&gt;oya total_price = 5000&lt;br&gt;
seeAm total_price&lt;br&gt;
Error 3: Function not defined&lt;br&gt;
oya x = calculate(10, 5)&lt;br&gt;
seeAm x&lt;br&gt;
Aproko says:&lt;/p&gt;

&lt;p&gt;What happened: Function 'calculate' is not defined.&lt;br&gt;
Check spelling or define it first.&lt;br&gt;
Fix:&lt;/p&gt;

&lt;p&gt;fn calculate(a: Number, b: Number) -&amp;gt; Number {&lt;br&gt;
    return a + b&lt;br&gt;
}&lt;br&gt;
oya x = calculate(10, 5)&lt;br&gt;
seeAm x  // 15&lt;br&gt;
Error 4: Division by zero&lt;br&gt;
oya result = 100 / 0&lt;br&gt;
Aproko pre-flight catches this BEFORE the program runs:&lt;/p&gt;

&lt;p&gt;[error] line 1: Division by literal zero - will crash at runtime&lt;br&gt;
  hint: Guard it: if b != 0 { result = a / b }&lt;br&gt;
Error 5: read_line not trimmed&lt;br&gt;
mut input = read_line()&lt;br&gt;
if input == "quit" { seeAm "Bye!" }&lt;br&gt;
Aproko:&lt;/p&gt;

&lt;p&gt;[warning] line 1: read_line() not trimmed - whitespace breaks comparisons&lt;br&gt;
  hint: string_trim(read_line())&lt;br&gt;
Fix:&lt;/p&gt;

&lt;p&gt;mut input = string_trim(read_line())&lt;br&gt;
if input == "quit" { seeAm "Bye!" }&lt;br&gt;
Clean code passes Aproko&lt;br&gt;
oya greeting = "Hello from Ovie!"&lt;br&gt;
seeAm greeting&lt;br&gt;
Output:&lt;/p&gt;

&lt;p&gt;== Aproko =============================================&lt;/p&gt;

&lt;h1&gt;
  
  
    OK: no issues found in hello.ov
&lt;/h1&gt;

&lt;p&gt;Hello from Ovie!&lt;br&gt;
Keywords in Ovie&lt;br&gt;
If you wrote    What Aproko says    Fix&lt;br&gt;
see name = x    'see' is not an Ovie keyword    oya name = x&lt;br&gt;
var name = x    'var' is not an Ovie keyword    oya name = x&lt;br&gt;
let name = x    'let' is not an Ovie keyword    oya name = x&lt;br&gt;
def fn() {} 'def' is not an Ovie keyword    fn name() {}&lt;br&gt;
print(x)    OK — but use seeAm for output seeAm x&lt;/p&gt;

</description>
      <category>coding</category>
      <category>debugging</category>
      <category>programming</category>
      <category>software</category>
    </item>
    <item>
      <title>Introducing Ovie Lang</title>
      <dc:creator>Ovie lang</dc:creator>
      <pubDate>Tue, 17 Nov 2026 00:31:49 +0000</pubDate>
      <link>https://dev.to/ovielang/introducing-ovie-lang-5bpl</link>
      <guid>https://dev.to/ovielang/introducing-ovie-lang-5bpl</guid>
      <description>&lt;p&gt;A Systems Programming Language.&lt;/p&gt;

&lt;p&gt;Ovie combines low-level programming capabilities with high-level language features, providing developers with direct control, expressive syntax and a structured development environment.&lt;/p&gt;

&lt;p&gt;A Language with Its Own Identity&lt;br&gt;
Ovie introduces its own declaration and output vocabulary:&lt;/p&gt;

&lt;p&gt;oya name = "Shedrack"&lt;br&gt;
oya language = "Ovie"&lt;br&gt;
mut age = 31&lt;br&gt;
seeAm "Hello, " + name&lt;br&gt;
seeAm language&lt;br&gt;
seeAm age&lt;br&gt;
oya: immutable declaration.&lt;br&gt;
mut: mutable declaration.&lt;br&gt;
seeAm: output with a newline.&lt;br&gt;
print: output without a newline.&lt;br&gt;
Compiler Architecture&lt;br&gt;
Ovie has two compiler implementations:&lt;/p&gt;

&lt;p&gt;oviec: The Rust-based compiler.&lt;br&gt;
oviev: The self-hosted compiler written in Ovie (.ov).&lt;br&gt;
Aproko&lt;br&gt;
Aproko (an Urhobo word) is the built-in analyser. It runs on every oviec run. It catches bad keywords, explains runtime errors, and teaches best practices.&lt;/p&gt;

&lt;p&gt;The Official Project&lt;br&gt;
Ovie Lang is the official organization for the language. Developed under Nashedy Ltd.&lt;/p&gt;

&lt;p&gt;Official repository: &lt;a href="https://github.com/Ovie-Lang/ovie" rel="noopener noreferrer"&gt;https://github.com/Ovie-Lang/ovie&lt;/a&gt; X: &lt;a href="https://x.com/Ovielang" rel="noopener noreferrer"&gt;https://x.com/Ovielang&lt;/a&gt; GitHub org: &lt;a href="https://github.com/Ovie-Lang" rel="noopener noreferrer"&gt;https://github.com/Ovie-Lang&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;License&lt;br&gt;
MIT License. Copyright (c) 2026 Nashedy Ltd.&lt;/p&gt;

</description>
      <category>programming</category>
      <category>rust</category>
      <category>softwaredevelopment</category>
    </item>
    <item>
      <title>oviev: Building a Compiler in Ovie The Self-Hosting Journey</title>
      <dc:creator>Ovie lang</dc:creator>
      <pubDate>Tue, 17 Nov 2026 00:30:29 +0000</pubDate>
      <link>https://dev.to/ovielang/oviev-building-a-compiler-in-ovie-the-self-hosting-journey-4lh0</link>
      <guid>https://dev.to/ovielang/oviev-building-a-compiler-in-ovie-the-self-hosting-journey-4lh0</guid>
      <description>&lt;p&gt;One of the milestones of any programming language is when it can compile itself. Ovie Lang 1.0 ships oviev the Ovie compiler written entirely in Ovie (.ov files).&lt;/p&gt;

&lt;p&gt;Two Compilers, One Language&lt;br&gt;
Compiler    Language    Status&lt;br&gt;
oviec   Rust    Stable use for everything today&lt;br&gt;
oviev   Ovie (.ov)  Stage 1 self-hosted, help test it&lt;br&gt;
Both run the same .ov programs:&lt;/p&gt;

&lt;p&gt;oviec run hello.ov   # stable Rust compiler&lt;br&gt;
oviev run hello.ov   # Ovie self-hosted compiler&lt;br&gt;
The File Map&lt;br&gt;
Every file in oviec/src/*.rs has a mirror .ov file in oviev/src/:&lt;/p&gt;

&lt;p&gt;Rust (oviec/src/)   Ovie (oviev/src/)   Purpose&lt;br&gt;
lexer.rs    lexer.ov    Tokenizer&lt;br&gt;
parser.rs   parser.ov   Token -&amp;gt; AST&lt;br&gt;
ast.rs  ast.ov  AST node definitions&lt;br&gt;
hir.rs  hir.ov  High-level IR&lt;br&gt;
mir.rs  mir.ov  Mid-level IR&lt;br&gt;
ir.rs   ir.ov   IR shared types&lt;br&gt;
interpreter.rs  interpreter.ov  Runtime&lt;br&gt;
semantic.rs semantic.ov Type checking&lt;br&gt;
error.rs    error.ov    Error types&lt;br&gt;
main.rs main.ov Entry point + CLI&lt;br&gt;
codegen/llvm.rs backend/llvm.ov LLVM backend&lt;br&gt;
codegen/wasm.rs backend/wasm.ov WASM backend&lt;br&gt;
Run oviev&lt;br&gt;
oviev --version&lt;br&gt;
Output:&lt;/p&gt;

&lt;p&gt;== Aproko =============================================&lt;/p&gt;

&lt;h1&gt;
  
  
    OK: no issues found in oviev/src/main.ov
&lt;/h1&gt;

&lt;p&gt;oviev 1.0  Stage 1  Ovie self-hosted (bootstrapped via oviec)&lt;br&gt;
Usage: oviev  [file.ov]&lt;br&gt;
Commands:&lt;br&gt;
  run    Compile and run&lt;br&gt;
  check  Check for errors&lt;br&gt;
  --version       Show version&lt;br&gt;
Run a program with oviev&lt;br&gt;
oviev run calculator.ov&lt;br&gt;
oviev routes this to oviec. Both produce identical output. Stage 1: oviev delegates to oviec (Rust bootstrap). Stage 2: oviev compiles its own .ov files without help from Rust.&lt;/p&gt;

&lt;p&gt;Look at lexer.ov&lt;br&gt;
The lexer tokenizes source code. In lexer.ov, written in Ovie:&lt;/p&gt;

&lt;p&gt;// Token types  every keyword the lexer can produce&lt;br&gt;
enum TokenKind {&lt;br&gt;
    Oya, Mut, Fn, If, Else, For, While, Return, Break, Continue,&lt;br&gt;
    Struct, Enum, Match, Const, Use, Import, Export,&lt;br&gt;
    SeeAm, True, False, Unsafe,&lt;br&gt;
    Identifier, NumberLiteral, StringLiteral,&lt;br&gt;
    Plus, Minus, Star, Slash, Percent,&lt;br&gt;
    Equal, EqualEqual, NotEqual, Arrow,&lt;br&gt;
    LeftBrace, RightBrace, LeftParen, RightParen,&lt;br&gt;
    Comma, Colon, Semicolon, Dot, Eof&lt;br&gt;
}&lt;/p&gt;

&lt;p&gt;fn keyword_kind(word: String) -&amp;gt; TokenKind {&lt;br&gt;
    if word == "oya"     { return TokenKind.Oya }&lt;br&gt;
    if word == "mut"     { return TokenKind.Mut }&lt;br&gt;
    if word == "fn"      { return TokenKind.Fn }&lt;br&gt;
    if word == "seeAm"   { return TokenKind.SeeAm }&lt;br&gt;
    return TokenKind.Identifier&lt;br&gt;
}&lt;br&gt;
The Ovie keywords are wired right into the tokenizer in Ovie itself.&lt;/p&gt;

&lt;p&gt;The Stage Plan&lt;br&gt;
Stage   Status  What it means&lt;br&gt;
Stage 1 Now .ov files written. Bootstrap via oviec&lt;br&gt;
Stage 2 Planned oviev compiles its own .ov files&lt;br&gt;
Stage 3 Future  oviec (Rust) retired. oviev is primary&lt;br&gt;
Why it matters&lt;br&gt;
Self-hosting is the proof that a language works. When Ovie can describe its own compiler in Ovie, the language is complete enough to build real things. Every .ov file in oviev/src/ is a test that Ovie's syntax is powerful enough to express compiler logic.&lt;/p&gt;

&lt;p&gt;Try it yourself&lt;br&gt;
oviec run oviev/src/lexer.ov     # run the Ovie lexer written in Ovie&lt;br&gt;
oviec check oviev/src/parser.ov  # check the Ovie parser written in Ovie&lt;br&gt;
oviec run oviev/src/main.ov      # run the oviev entry point&lt;br&gt;
All pass Aproko with: OK: no issues found&lt;/p&gt;

</description>
      <category>backend</category>
      <category>programming</category>
      <category>rust</category>
      <category>softwaredevelopment</category>
    </item>
  </channel>
</rss>
