BERK Language Support for VS Code

BERK is a systems programming language that brings RTOS semantics to compile-time.

"BERK does not replace an RTOS kernel.
It replaces how RTOS-style applications are expressed and verified."

Positioning:

BERK Language & BERK-RTOS: Two Products, One Ecosystem

BERK is a systems programming language. BERK-RTOS is a separate real-time operating system product that is powered by BERK language.

BERK-RTOS is the only RTOS with a dedicated systems programming language designed specifically for it.

15 World-First Features:

14 Sectors, Single Kernel:

Project Scale: 139,799 LOC · 218 files · 28 BSPs · 600+ tests

Docs: Language Guide · Stdlib API · Demos & Tests

CI & Test Status

⚠️ Note on GitHub Actions test results

Some CI checks may currently fail.

This is a known and temporary situation caused by:

• Ongoing core language and runtime evolution
• Recent internal architectural refactoring
• Test cases not yet fully updated to reflect new behavior

The implementation is evolving ahead of the test suite, which is being actively restructured.

✔ Runtime stability
✔ Deterministic execution goals
✔ Long-term test discipline

remain core project principles.

Test updates and CI stabilization are part of the active roadmap.

Website: berk-tech.com

Docs: Language Guide · Stdlib API · Demos & Tests

Latest Release: BERK v1.0.0

README (Turkish): https://github.com/ArslantasM/berk-release/blob/main/README_TR.md

Education Portal: BERK Learn – Free interactive systems programming courses (10 lessons, ~10 hours):

Curriculum: Hello World → Variables → Control Flow → Functions → Structs → Enums → Error Handling → Ownership → Collections → Mini Project

Whitepaper (Defense / Industrial):

• EN: https://github.com/ArslantasM/berk-release/blob/main/Defense%20-%20Industrial%20Whitepaper.md
• TR: https://github.com/ArslantasM/berk-release/blob/main/Defense%20-%20Industrial%20Whitepaper%20(TR).md

Capability Snapshot (high level):

• AI/ML (Edge): CUIO concept for compile-time oriented, certifiable inference orchestration (profile-dependent).
• Embedded + HAL: platform-oriented modules (e.g., ESP32 / STM32 / Arduino / RISC-V / generic profiles).
• Industrial integrations: protocol modules (e.g., OPC-UA / MQTT / CoAP / EtherCAT / PROFINET).
• Hardware Bridge: PC↔device communication (e.g., Serial / Firmata / Modbus RTU / SLIP / BinProto).

Project Scale (current snapshot):

v1.0.0 Safety-Critical Features (January 2026)

BERK v1.0.0 brings compile-time verification for safety-critical systems.

Certification-Oriented Features:

Deployment Profiles:

• Defense Profile: Maximum analyzability, allocation-free builds, strict determinism
• Industrial Profile: Mixed-criticality support, protocol integration, practical maintainability

Target Standards:

✓ DO-178C (Avionics)
✓ IEC 62304 (Medical)
✓ ISO 26262 (Automotive)
✓ IEC 61508 (Industrial)
✓ EN 50128 (Railway)
✓ ECSS-E-ST-40C (Space)

Full API Documentation: Coming with v1.0.0 release

Why BERK?

BERK is first and foremost a systems programming language for safety-critical embedded systems, deterministic mixed-criticality runtimes, and high-performance messaging.

At a glance (platform + capabilities):

• AI/ML (Edge): CUIO concept for compile-time oriented, certifiable inference orchestration (profile-dependent).
• Embedded systems: designed for MCU/SBC workflows; RTOS-hosted or bare-metal style integrations.
• Industrial connectivity: protocol-oriented modules (e.g., OPC-UA / MQTT / CoAP / fieldbus families) to bridge control and integration layers.
• HAL + Hardware Bridge: talk to real hardware via HAL abstractions and PC↔device bridges (USB/Serial class workflows).

What makes it different:

• RTOS semantics at compile-time: scheduling/timing/communication constraints are designed to surface as compile-time checks and diagnostics.
• Bilingual syntax (Turkish + English): write in TR, EN, or mix both in the same file.
• Nano runtime approach: cooperative execution model oriented toward deterministic behavior.
• Zero-allocation hot paths: designed for predictable latency (profile-dependent).
• HPC messaging path: SPSC / bounded-MPSC primitives for very high throughput.

Quick Start

1. Install the extension from VS Code Marketplace.

2. Create a file: hello.berk

3. Write code (Turkish, English, or mixed):

// Turkish
yaz("Merhaba BERK!")

// English
print("Hello BERK!")

// Mixed
değişken x = 42
let y = 58
yaz("Toplam: ", x + y)

4. Run:

• Ctrl+Shift+B → build/run task
• Command Palette → BERK: Run Current File

BerkRTOS - Real-Time Task Example

BERK-RTOS is a separate real-time operating system product powered by BERK language. BERK provides native RTOS semantics at compile-time. Define tasks with priorities, periods, and stack sizes using the bilingual syntax:

Türkçe (Turkish):

import rtos::{görev, Öncelik, Mutex, Kanal};

// Sensör verisi yapısı
yapı SensörVerisi {
    sıcaklık: f32,
    basınç: f32,
    zaman_damgası: u64,
}

// Paylaşılan mutex ve kanal
statik veri_mutex: Mutex<SensörVerisi> = Mutex::yeni(SensörVerisi {
    sıcaklık: 0.0,
    basınç: 0.0,
    zaman_damgası: 0,
});

statik veri_kanal: Kanal<SensörVerisi, 16> = Kanal::yeni();

// Sensör okuma görevi - yüksek öncelik, 10ms periyot
görev SensörOkuyucu {
    öncelik: Öncelik::YÜKSEK,
    periyot: 10ms,
    yığın: 2KB,
    son_tarih: 8ms,
    
    başla() {
        döngü {
            bırak veri = SensörVerisi {
                sıcaklık: sensör_oku_sıcaklık(),
                basınç: sensör_oku_basınç(),
                zaman_damgası: rtos::şimdi(),
            };
            
            // Mutex ile güvenli erişim
            veri_mutex.kilitle(|v| {
                *v = veri;
            });
            
            // Kanala gönder
            veri_kanal.gönder(veri);
            
            rtos::bekle_periyot();
        }
    }
}

// Veri işleme görevi - normal öncelik
görev Veriİşleyici {
    öncelik: Öncelik::NORMAL,
    periyot: 50ms,
    yığın: 4KB,
    
    başla() {
        döngü {
            eğer bırak Bazı(veri) = veri_kanal.al(100ms) {
                eğer veri.sıcaklık > 80.0 {
                    alarm_tetikle("Yüksek sıcaklık!");
                }
            }
            rtos::bekle_periyot();
        }
    }
}

English:

import rtos::{task, Priority, Mutex, Channel};

// Sensor data structure
struct SensorData {
    temperature: f32,
    pressure: f32,
    timestamp: u64,
}

// Shared mutex and channel
static data_mutex: Mutex<SensorData> = Mutex::new(SensorData {
    temperature: 0.0,
    pressure: 0.0,
    timestamp: 0,
});

static data_channel: Channel<SensorData, 16> = Channel::new();

// Sensor reading task - high priority, 10ms period
task SensorReader {
    priority: Priority::HIGH,
    period: 10ms,
    stack: 2KB,
    deadline: 8ms,
    
    start() {
        loop {
            let data = SensorData {
                temperature: read_temperature_sensor(),
                pressure: read_pressure_sensor(),
                timestamp: rtos::now(),
            };
            
            // Safe access with mutex
            data_mutex.lock(|v| {
                *v = data;
            });
            
            // Send to channel
            data_channel.send(data);
            
            rtos::wait_period();
        }
    }
}

// Data processing task - normal priority
task DataProcessor {
    priority: Priority::NORMAL,
    period: 50ms,
    stack: 4KB,
    
    start() {
        loop {
            if let Some(data) = data_channel.receive(100ms) {
                if data.temperature > 80.0 {
                    trigger_alarm("High temperature!");
                }
            }
            rtos::wait_period();
        }
    }
}

BERK-RTOS IDE Integration

What is BERK? BERK is a systems programming language. BERK-RTOS is a separate product – a minimal real-time kernel powered by BERK language and optimized with BERK's compile-time constructs.

The VS Code extension provides specialized analysis and visualization tools for BERK-RTOS development:

Task-Aware Code Analysis

RTOS-Aware Linting

// ⚠️ Linter warning: Potential priority inversion
task LowPriorityTask {
    priority: Priority::LOW,
    start() {
        high_priority_mutex.lock(|v| {  // ← Warning
            // ...
        });
    }
}

Live Diagrams

• Task Graph: Task dependencies and priority relationships
• IPC Map: Channel and mutex usage map
• Timeline View: Task scheduling simulation

Memory Safety Analysis

• Stack overflow risk detection
• Heap allocation warnings (for zero-heap profile)
• DMA buffer alignment verification

Note: BERK is a systems programming language. BERK-RTOS is a separate RTOS product powered by BERK. Together they form an integrated ecosystem + compiler + runtime + IDE + analysis tool solution.

VS Code Features

• Syntax highlighting for .berk files
• IntelliSense completion (TR/EN keywords + symbols)
• Real-time diagnostics (parser/type/lint)
• Hover type info + signature help
• Go to definition / references / rename
• Code actions & CodeLens (where available)

Energy Efficiency

BERK-RTOS mimarisinin deterministik, düşük gecikmeli ve zero-heap tasarımı enerji tüketimini dramatik biçimde azaltır.

Energy Savings Sources

Expected Savings

This is a critical selling point for IoT modules, industrial control devices, and telecom base station hardware.

Extension Settings (Common)

{
  "berk.preferredLanguage": "auto",
  "berk.compilerPath": "berk-lang",
  "berk.languageServerPath": "berk-lsp",
  "berk.enableLinter": true
}

Bioinformatics & Finance Modules (NEW!)

BERK v0.7.0 introduces comprehensive domain-specific libraries:

Bioinformatics (stdlib/bio/)

14 modules for molecular biology, genomics, and computational biology:

import bio::{DnaSequence, FastaReader, Aligner};
import bio::datasources::{AlphaFoldClient, UniProtClient};
import bio::databases::{KeggClient, StringDbClient};

// DNA sequence analysis
bırak dna = DnaSequence::yeni("ATGCGATCGATCG");
bırak gc_içeriği = dna.gc_content();
bırak tamamlayıcı = dna.reverse_complement();

// Fetch protein structure from AlphaFold
bırak alphafold = AlphaFoldClient::yeni();
bırak yapı = alphafold.get_structure("P12345").await?;

// Query protein-protein interactions from STRING
bırak string_db = StringDbClient::yeni();
bırak etkileşimler = string_db.get_interactions("TP53", 9606).await?;

Modules: sequence, fasta, fastq, sam, vcf, alignment, assembly, protein, crispr, pathway, phylo, omics, datasources, databases

Finance & Trading (stdlib/finance/)

6 modules for algorithmic trading and risk management:

import finance::{Price, OrderBook, Order, RiskManager};
import finance::derivatives::{BlackScholes, Option};
import finance::backtesting::Backtester;

// Order book with microsecond latency
bırak emir_defteri = OrderBook::yeni("BIST100");
bırak alış = Order::limit_buy(Price::from_float(150.50), 1000);
emir_defteri.submit(alış);

// Black-Scholes option pricing
bırak opsiyon = Option::call(
    spot: 100.0,
    strike: 105.0,
    maturity: 0.25,  // 3 months
    volatility: 0.20,
    risk_free: 0.05,
);
bırak fiyat = BlackScholes::price(&opsiyon);
bırak delta = BlackScholes::delta(&opsiyon);

// Risk calculation (VaR, CVaR)
bırak risk = RiskManager::yeni();
bırak var_95 = risk.value_at_risk(&portföy, 0.95, 1);

Modules: market_data, order_book, risk, derivatives, backtesting, mod

Safety-Critical Domain Libraries

BERK provides specialized libraries for industries with strict certification requirements:

Avionics (stdlib/avionics/) - DO-178C

5 modules for aerospace software development:

import avionics::{Arinc429, Arinc664, MilStd1553};
import avionics::do178c::{DalLevel, RequirementTrace};

// ARINC 429 bus communication
bırak bus = Arinc429::yeni(kanal: 1, hız: Arinc429::HIGH_SPEED);
bırak mesaj = bus.oku_etiket(0o310)?;  // Octal label

// DO-178C traceability
#[requirement("REQ-NAV-001")]
#[dal(DalLevel::A)]
fn hesapla_irtifa(basınç: f64) -> f64 {
    // DAL-A certified altitude calculation
    44330.0 * (1.0 - (basınç / 101325.0).powf(0.1903))
}

Modules: arinc429, arinc664, mil1553, do178c, mod

ADAS (stdlib/adas/) - ISO 26262

7 modules for autonomous driving systems:

import adas::{Perception, Planning, Control};
import adas::v2x::{V2xMessage, DsrcRadio};
import adas::safety::{AsilLevel, SafetyGoal};

// Object detection with ASIL-D safety
#[asil(AsilLevel::D)]
görev NesneAlgılama {
    öncelik: Öncelik::EN_YÜKSEK,
    periyot: 20ms,
    son_tarih: 15ms,  // Hard deadline
    
    başla() {
        döngü {
            bırak nesneler = lidar.algıla();
            bırak tehditler = nesneler.filtrele(|n| n.mesafe < 50.0);
            planlayıcı.güncelle(tehditler);
            rtos::bekle_periyot();
        }
    }
}

// V2X communication
bırak v2x = DsrcRadio::yeni();
v2x.yayınla(V2xMessage::acil_fren(konum, hız));

Modules: perception, planning, control, localization, v2x, safety, mod

Medical (stdlib/medical/) - IEC 62304

4 modules for medical device software:

import medical::{IEC62304, RiskManagement, AuditLog};
import medical::risk::{Severity, Probability, RiskLevel};

// IEC 62304 Class C software unit
#[software_class(IEC62304::ClassC)]
#[risk_control("RC-001")]
fn dozaj_hesapla(hasta_kg: f64, ilaç_mg_kg: f64) -> Sonuç<f64, TıbbiHata> {
    eğer hasta_kg <= 0.0 || ilaç_mg_kg <= 0.0 {
        dön Hata(TıbbiHata::GeçersizParametre);
    }
    bırak dozaj = hasta_kg * ilaç_mg_kg;
    
    // Audit trail
    AuditLog::kaydet("dozaj_hesaplama", dozaj);
    
    Tamam(dozaj)
}

Modules: iec62304, risk, audit, mod

Railway (stdlib/railway/) - EN 50128

5 modules for rail transport systems:

import railway::{ETCS, Interlocking, Signaling};
import railway::en50128::{SilLevel, SafetyFunction};

// SIL-4 interlocking logic
#[sil(SilLevel::SIL4)]
fn makas_kilit_kontrol(makas_id: u32, istek: MakasKonum) -> KilitSonucu {
    bırak mevcut = interlocking.makas_durumu(makas_id);
    bırak rota_çakışma = interlocking.rota_kontrol(makas_id);
    
    eğer rota_çakışma {
        dön KilitSonucu::Reddedildi("Rota çakışması");
    }
    
    interlocking.makas_hareket(makas_id, istek)
}

// ETCS Level 2 movement authority
bırak etcs = ETCS::yeni(seviye: 2);
bırak ma = etcs.hareket_yetkisi_al()?;

Modules: etcs, interlocking, signaling, en50128, mod

Space (stdlib/space/) - ECSS

5 modules for spacecraft software:

import space::{CCSDS, FDIR, Mission};
import space::ecss::{PacketType, ServiceType};

// CCSDS telemetry packet
bırak paket = CCSDS::Telemetry::yeni(
    apid: 0x123,
    sequence: mission.sequence_counter(),
    data: sensör_verisi.serialize(),
);
downlink.gönder(paket);

// Fault Detection, Isolation, Recovery
#[fdir_monitored]
görev GüneşPaneliKontrol {
    öncelik: Öncelik::YÜKSEK,
    periyot: 100ms,
    
    başla() {
        döngü {
            bırak güç = panel.ölç_güç();
            eğer güç < eşik {
                FDIR::bildir(FaultType::PowerAnomaly);
            }
            rtos::bekle_periyot();
        }
    }
}

Modules: ccsds, ecss, fdir, mission, mod

Robotics (stdlib/robotics/)

8 modules for robotic systems:

import robotics::{Arm, Drone, Navigation, Swarm};
import robotics::px4::{FlightMode, MavlinkMessage};

// 6-DOF robot arm control
bırak kol = Arm::yeni(dof: 6, kinematik: "PUMA560");
bırak hedef = Pose::yeni(x: 0.5, y: 0.3, z: 0.4, rx: 0.0, ry: PI, rz: 0.0);
bırak yol = kol.inverse_kinematics(hedef)?;
kol.hareket(yol, hız: 0.5);

// Drone swarm coordination
bırak sürü = Swarm::yeni(drone_sayısı: 10);
sürü.formasyon_belirle(Formasyon::V_şekli);
sürü.hedef_git(GPS::yeni(lat: 41.0, lon: 29.0));

Modules: arm, drone, px4, navigation, rov, ugv, swarm, mod

Telecom (stdlib/telecom/) – Strategic Expansion Area

9 modules for telecommunications. BERK's determinism and low-latency capabilities make it ideal for modern telecom infrastructure.

Why BERK for Telecom?

Target Markets:

import telecom::{TSN, PTP, SDR, ORAN};
import telecom::scheduler::{TrafficClass, GateControl};

// Time-Sensitive Networking
bırak tsn = TSN::yeni(arayüz: "eth0");
tsn.trafik_sınıfı_ekle(TrafficClass::CriticalControl, öncelik: 7);
tsn.gate_schedule_yükle(schedule);

// Precision Time Protocol (IEEE 1588)
bırak ptp = PTP::yeni(mode: PTP::BoundaryClock);
bırak senkron = ptp.senkronize()?;
yaz("Offset: {} ns", senkron.offset_ns);

// Software Defined Radio
bırak sdr = SDR::yeni(device: "usrp");
sdr.frekans_ayarla(2.4e9);  // 2.4 GHz
bırak örnekler = sdr.al(1024);

Modules: tsn, ptp, synce, sdr, oran, frame_buffer, packet_queue, scheduler, mod

Real-World BERK Projects (Showcase)

Looking for real-world, production-oriented examples?

Explore the BERK Showcase Repository: https://github.com/ArslantasM/berk-showcase

This repository contains:

• Embedded & RTOS-oriented projects
• Hardware–software co-design examples
• Deterministic and safety-aware systems
• Reference architectures using BERK

VS Code Extension v0.7.0 - New Features

LLVM Backend Integration - 33 Platform Support

Full LLVM IR backend (LLVM 17.0.6) support for native code generation across 33 platforms:

Cross-compilation example:

# ARM64 Linux
berk-lang build main.berk --target aarch64-linux-gnu

# WebAssembly
berk-lang build main.berk --target wasm32-wasi

# RISC-V embedded
berk-lang build main.berk --target riscv32-none-elf

# Windows from Linux
berk-lang build main.berk --target x86_64-windows-msvc

// Compile with optimization
// Settings: berk.llvm.optimizationLevel = "O2"

DAP Debugger Support

Full Debug Adapter Protocol support for interactive debugging:

launch.json configuration:

{
  "type": "berk",
  "request": "launch",
  "name": "Debug BERK Program",
  "program": "${file}",
  "cwd": "${workspaceFolder}",
  "stopOnEntry": true,
  "optimizationLevel": "O0"
}

UTF-8 Turkish Character Support

Automatic UTF-8 encoding for PowerShell terminals - Turkish characters display correctly:

Supported characters: ğ ü ş ı ö ç Ğ Ü Ş İ Ö Ç

Manual setup: Command Palette → BERK: Setup UTF-8 Terminal

New Commands

Stdlib Update

Updated standard library with 506 files across 23 module directories:

Keyboard Shortcuts

Status Bar

• BERK status indicator in bottom-left
• Click to run current file
• Shows extension status

Resources

• Language Guide: https://arslantasm.github.io/berk_pages/
• Standard Library Docs: https://arslantasm.github.io/berk-stdlib-docs/
• Repo: https://github.com/ArslantasM/berk
• Issues: https://github.com/ArslantasM/berk/issues