Forem: TwisterRL

New Map Split Code in Nebula: Say Goodbye to Endless and Opaque C++ Builds

TwisterRL — Wed, 01 Apr 2026 08:35:22 +0000

Nebula dévoile son nouveau Code Map split : la visualisation intelligente des builds C++ enfin simplifiée

Les développeurs C++ le savent trop bien : compiler un gros projet peut vite devenir un cauchemar. Entre les temps de compilation interminables, les headers qui polluent tout le codebase et les logs de build illisibles, optimiser un build relève souvent de l’archéologie logicielle.

Bonne nouvelle : Nebula vient de sortir une fonctionnalité qui change la donne.

Un Code Map en mode split, enfin adapté au C++

La nouvelle feature, baptisée Code Map split, divise l’interface en deux panneaux clairs :

Panneau de gauche : tous vos fichiers d’en-tête (.h et .hpp)
Panneau de droite : vos fichiers sources (.cpp)

Chaque fichier est automatiquement tagué pendant le build avec des informations précieuses :

Les warnings et erreurs
Le temps de compilation réel par fichier
Une représentation visuelle (couleurs) des performances

Résultat ? Vous repérez en un seul coup d’œil les goulots d’étranglement, les headers trop lourds qui ralentissent des dizaines de fichiers, et les sources qui méritent une optimisation urgente.

Exemple concret avec libvterm

Dans la capture partagée par l’équipe, on voit le projet libvterm analysé. Le graphique de dépendances utilise un code couleur intuitif :

Vert → compilation rapide
Jaune → acceptable
Rouge → très lent

Le fichier harness.c apparaît clairement en rouge, immédiatement identifiable comme le principal coupable du ralentissement. Plus besoin de lancer des outils externes comme ninja -t graph, clang -ftime-trace ou de parser des centaines de lignes de logs : tout est visuel et intégré.

Pourquoi cette fonctionnalité est-elle particulièrement puissante en C++ ?

Le C++ souffre historiquement de deux grands problèmes de build :

La dépendance massive aux en-têtes (header hell)
La difficulté à mesurer précisément où passe le temps pendant la compilation

Le Code Map split de Nebula attaque ces deux points de front :

Il rend visibles les chaînes de dépendances entre headers et sources
Il quantifie le coût réel de chaque fichier
Il permet d’identifier instantanément les fichiers qui méritent un refactor (PImpl, forward declarations, modules C++20, etc.)

Pour les équipes travaillant sur des engines de jeu, des simulateurs, des logiciels embarqués ou tout projet de taille importante, cette visualisation peut faire gagner des heures, voire des jours de travail par mois.

Un pas de plus vers des outils C++ modernes et agréables

Cette feature s’inscrit dans la tendance actuelle : rendre le C++ moins douloureux sans en sacrifier la performance. Alors que des outils comme CMake, Meson ou Bazel améliorent déjà la gestion de build, Nebula va plus loin en apportant une couche de visualisation et d’analyse en temps réel.

Points forts observés :

Intégration native dans le workflow de build
Diagnostic ultra-rapide des problèmes
Interface claire et pensée pour les gros projets

Bien sûr, l’efficacité réelle dépendra de la précision de l’analyse sur des configurations très complexes (unity builds, préprocesseurs custom, etc.), mais l’idée de base est excellente.

Verdict

C’est une des meilleures améliorations récentes que j’ai vues dans l’écosystème des outils C++. Simple, visuelle et directement utile au quotidien. Si vous passez beaucoup de temps à optimiser vos builds, Nebula mérite clairement un essai.

N’hésitez pas à partager vos retours en commentaire !

5 C++ Tips Every Developer Should Know

TwisterRL — Fri, 20 Feb 2026 08:25:03 +0000

C++ remains one of the most powerful and widely used programming languages in systems programming, game development, finance, embedded systems, and high-performance applications. Its flexibility and performance come at a cost: complexity. Mastering C++ requires understanding not only syntax, but also memory management, object lifetimes, and modern language features.

In this article, we will explore five essential C++ tips that can significantly improve your code quality, performance, and maintainability. Whether you are a beginner or an intermediate developer, these principles will help you write safer and more modern C++.

1. Prefer RAII Over Manual Resource Management

What Is RAII?

RAII stands for Resource Acquisition Is Initialization. It is a core C++ idiom where resource management is tied to object lifetime.

In simple terms:

Resources are acquired in a constructor.
Resources are released in a destructor.
When the object goes out of scope, cleanup happens automatically.

Why It Matters

Manual memory management using new and delete is error-prone. Forgetting to free memory leads to leaks. Freeing memory too early leads to undefined behavior.

Bad Example

void process() {
    int* data = new int[100];

    // ... some logic ...

    delete[] data; // What if we forget this?
}

If an exception occurs before delete[] is called, memory leaks.

Better Approach: Use Smart Pointers

#include <memory>

void process() {
    std::unique_ptr<int[]> data = std::make_unique<int[]>(100);

    // ... logic ...

} // Memory automatically released here

Or for shared ownership:

std::shared_ptr<MyClass> obj = std::make_shared<MyClass>();

Key Takeaway

Avoid raw new and delete. Use:

std::unique_ptr
std::shared_ptr
std::vector
std::string

These follow RAII and automatically manage memory.

2. Use `const` Correctly and Aggressively

Why `const` Is Powerful

const is not just about preventing modification. It communicates intent and allows the compiler to enforce correctness.

Adding const:

Prevents accidental modification
Improves readability
Enables better compiler optimizations
Helps avoid subtle bugs

Example: Const Member Functions

class User {
public:
    std::string getName() const {
        return name;
    }

private:
    std::string name;
};

The const at the end guarantees that getName() does not modify the object.

Const References

Instead of copying large objects:

void print(const std::string& text) {
    std::cout << text << std::endl;
}

Benefits:

No copy
No modification
Clear intent

Const Pointers

const int* ptr;      // pointer to const int
int* const ptr2;     // const pointer to int
const int* const p;  // const pointer to const int

Understanding these distinctions helps avoid confusion in complex codebases.

Key Takeaway

Use const wherever possible. Start with everything const, then remove it only when necessary.

3. Prefer `std::vector` Over Raw Arrays

Why Avoid Raw Arrays?

Raw arrays:

Do not track their size
Decay into pointers
Are unsafe in many contexts

Example:

int arr[5] = {1, 2, 3, 4, 5};

Once passed to a function:

void print(int arr[]) {
    // size information lost
}

Better: `std::vector`

#include <vector>

std::vector<int> values = {1, 2, 3, 4, 5};

Advantages:

Knows its size (values.size())
Automatically resizes
Exception safe
Integrates with STL algorithms

Example with Algorithms

#include <algorithm>

std::sort(values.begin(), values.end());

You get powerful functionality with minimal effort.

Performance Consideration

Some developers worry about performance. In practice:

std::vector is extremely efficient.
It uses contiguous memory.
It is often identical to raw arrays in performance.

Key Takeaway

Use std::vector by default. Only use raw arrays in rare, low-level scenarios.

4. Understand Move Semantics

Move semantics, introduced in C++11, are essential for writing efficient modern C++.

The Problem: Expensive Copies

Consider this class:

class Buffer {
public:
    Buffer(size_t size)
        : size(size), data(new int[size]) {}

    ~Buffer() {
        delete[] data;
    }

private:
    size_t size;
    int* data;
};

Copying this object duplicates the memory allocation, which is expensive.

Move Constructor

Buffer(Buffer&& other) noexcept
    : size(other.size), data(other.data) {
    other.data = nullptr;
    other.size = 0;
}

Instead of copying, we transfer ownership.

Using `std::move`

std::vector<Buffer> buffers;
Buffer buf(1000);

buffers.push_back(std::move(buf));

std::move converts buf into an rvalue reference, enabling move semantics.

Why It Matters

Move semantics:

Avoid unnecessary copies
Improve performance
Are essential in container-heavy code

Rule of Five

If your class manages resources, you likely need:

Destructor
Copy constructor
Copy assignment operator
Move constructor
Move assignment operator

Or better: follow RAII and use smart pointers to avoid implementing them manually.

Key Takeaway

Understand move semantics deeply. They are critical for modern, efficient C++.

5. Leverage the Standard Library

One of the biggest mistakes in C++ development is reinventing what the Standard Library already provides.

Avoid Writing Custom Implementations

Do not manually:

Implement sorting algorithms
Write custom linked lists
Manage memory pools unnecessarily

Use:

#include <algorithm>
#include <map>
#include <unordered_map>
#include <set>
#include <thread>
#include <chrono>

Example: Algorithm Instead of Loop

Instead of:

for (auto& v : values) {
    v *= 2;
}

You can use:

std::transform(values.begin(), values.end(), values.begin(),
               [](int v) { return v * 2; });

This expresses intent clearly.

Use `std::optional`

Instead of returning sentinel values:

#include <optional>

std::optional<int> findValue(int x) {
    if (x > 0)
        return x;
    return std::nullopt;
}

This makes failure states explicit and safer.

Use `std::filesystem`

Instead of platform-specific file handling:

#include <filesystem>

std::filesystem::path p = "data.txt";
if (std::filesystem::exists(p)) {
    // ...
}

Key Takeaway

The Standard Library is powerful and battle-tested. Learn it thoroughly. It will make your code cleaner, safer, and more expressive.

Conclusion

C++ is not just about syntax; it is about understanding ownership, lifetime, and abstraction. By applying the following principles:

Use RAII instead of manual memory management
Apply const consistently
Prefer std::vector over raw arrays
Master move semantics
Leverage the Standard Library

You move from writing functional C++ to writing professional C++.

Modern C++ (C++11 and beyond) provides powerful tools to reduce bugs and increase clarity. The key is not to use every feature, but to use the right features thoughtfully.

Invest time in understanding these concepts deeply. They form the foundation of clean, efficient, and maintainable C++ code.

Subagents and web search in Claude Code

TwisterRL — Tue, 17 Feb 2026 09:39:12 +0000

Subagents and web search in Claude Code

TwisterRL ・ Feb 17

#pgaichallenge #code #ai #programming

Subagents and web search in Claude Code

TwisterRL — Tue, 17 Feb 2026 09:12:31 +0000

Ollama now supports subagents and web search in Claude Code. No MCP servers or API keys required.

Get started

ollama launch claude --model minimax-m2.5:cloud

Subagents

Subagents can run tasks in parallel, such as file search, code exploration, and research, each in their own context.

Some models will naturally trigger subagents when needed (minimax-m2.5, glm-5, kimi-k2.5), but you can force triggering subagents by telling the model to “use/spawn/create subagents”

Example prompts:

> spawn subagents to explore the auth flow, payment integration, and notification system

> create subagents to map the database queries, trace the API routes, and catalog error handling patterns

Web search

When a model needs current information, Ollama handles the search and returns results directly without any additional configuration. Subagents can leverage web search to research topics in parallel and come back with actionable results.

Example prompts:

> research the postgres 18 release notes, audit our queries for deprecated patterns, and create migration tasks

> create 3 research agents to research how our top 3 competitors price their API tiers, compare against our current pricing, and draft recommendations

Recommended models

minimax-m2.5:cloud
glm-5:cloud
kimi-k2.5:cloud

Happy Coding!

Most developers know == is dangerous. But do you know why [] == false is actually true? 🤯 Let’s break it down.

TwisterRL — Mon, 16 Feb 2026 10:21:16 +0000

JavaScript’s Weirdest Comparison

TwisterRL ・ Feb 16

#javascript #programming #webdev #beginners

JavaScript’s Weirdest Comparison

TwisterRL — Mon, 16 Feb 2026 10:18:50 +0000

[] == false        // true
[] == ![]          // true

Wait… what? 🤯

How can an empty array be equal to false?

Let’s break it down

JavaScript’s == operator performs type coercion.

That means it tries to convert values to the same type before comparing them.

Step 1

[] == false

false becomes 0
[] becomes "" (empty string)
"" becomes 0

So we end up with:

0 == 0  // true

Step 2

[] == ![]

First evaluate ![]:

[] is truthy
![] becomes false

So now we have:

[] == false

Which we already know is:

true

Why this matters

The == operator can lead to unexpected results because of implicit type conversion.

That’s why most developers prefer:

===

It compares values without coercion.

Takeaway

JavaScript doesn’t behave randomly.
It follows rules — even strange ones.

Understand coercion, and the weirdness disappears.

Happy coding ✨

Pourquoi j’ai arrêté d’utiliser VS Code pour mes projets C++

TwisterRL — Mon, 16 Feb 2026 09:25:49 +0000

En 2026, on ne manque clairement pas d’éditeurs de code.

Entre Visual Studio Code, Visual Studio, CLion et tous les autres, le problème n’est pas le choix.

Alors pourquoi construire le mien ?

La réponse est simple :
je voulais comprendre ce qui se passe vraiment sous le capot.

Le moment où ça a basculé

Pendant des années, j’ai utilisé des éditeurs puissants, modernes, remplis de fonctionnalités.

Mais à force, j’ai commencé à remarquer des choses :

Démarrage lent

Consommation mémoire élevée

Petits lags pendant le scroll

Sensation d’utiliser un navigateur plus qu’un outil natif

Ce n’est pas que ces outils sont mauvais.
Ils sont impressionnants.

Mais moi, je voulais autre chose.

Je voulais un éditeur qui :

démarre instantanément
reste léger
ne charge pas 200 modules au lancement
soit pensé d’abord pour la performance

Construire Nebula

C’est comme ça qu’est né Nebula.

Au début, c’était un simple prototype.
Juste une fenêtre. Du texte. Un curseur.

Puis les problèmes ont commencé.

Un éditeur de texte paraît simple… jusqu’à ce que tu essaies d’en écrire un.

Tu découvres que :

rendre des milliers de glyphes rapidement, c’est compliqué
mesurer du texte coûte cher
le scroll peut casser ton framerate
la coloration syntaxique peut tuer les performances
Et là tu comprends quelque chose d’important :
La performance n’est pas une optimisation.
C’est une décision d’architecture.

Pourquoi rester minimaliste

Je pourrais ajouter :

LSP complet
debugger intégré
terminal embarqué
système d’extensions

Mais plus tu ajoutes, plus tu complexifies.

Et plus tu risques de perdre ce qui rend l’outil agréable.

Nebula est volontairement focalisé.

Ouvrir un fichier.
Éditer.
Scroller sans lag.
Rester fluide même avec de gros fichiers.

C’est tout.

Le vrai objectif

Au fond, Nebula n’est pas juste un éditeur.

C’est un exercice de compréhension.

Comprendre :

le rendering
les buffers de texte
l’architecture UI
la gestion mémoire
la perception utilisateur

Construire un éditeur, c’est comme construire un mini système d’exploitation spécialisé.

Et c’est probablement l’un des meilleurs projets pour apprendre la performance réelle.

Et maintenant ?

Nebula continue d’évoluer.

Thèmes dynamiques.
Drag & drop.
Améliorations sur les gros fichiers.

Mais l’objectif reste le même :

Faire un éditeur léger qui donne l’impression d’être instantané.
Pas parce qu’il a moins de features.

Mais parce qu’il est pensé différemment.

I have leave VS code for this code editor.

TwisterRL — Sat, 14 Feb 2026 22:36:34 +0000

Nebula: Building a Fast, Lightweight C++ Code Editor

TwisterRL ・ Feb 14

#programming #news #code #cpp

Nebula: Building a Fast, Lightweight C++ Code Editor

TwisterRL — Sat, 14 Feb 2026 22:29:28 +0000

Most code editors today are impressive… but also huge.

They ship with dozens of features, plugins, telemetry layers, web engines, background services, and sometimes feel closer to a browser than a native tool. That’s not necessarily bad — but I wanted something different.

I wanted a code editor that feels:

instant
small
native
focused
and especially fast for C++ workflows

That’s why I started Nebula, a lightweight C++ code editor with a strong focus on rendering performance, clean architecture, and a minimal but modern feature set.

In this article, I’ll share what I built, what I learned, and what changed recently — including dynamic theme support and drag & drop.

Why build a new editor in 2026?

This is the obvious question.

The honest answer:
I didn’t build Nebula because there aren’t enough editors. I built it because:

1) I wanted full control over performance

I wanted to measure and optimize everything: startup time, memory, UI redraw cost, text rendering speed.

2) I wanted a native architecture

No webview. No Electron. No huge runtime.

3) I wanted something simple

A fast editor that does the core job well:
open files, edit, search, syntax highlight, manage projects.

Goals and constraints

Before writing any code, I defined a few hard constraints:

Small binary
Low memory usage
Fast startup
Smooth scrolling even with large files
Clean UI
No plugin system (for now)
No dependency explosion

This is a different mindset than “add features until it becomes a full IDE”.

Architecture overview

Nebula is built around a few main layers:

Core layers

UI layer (windows, panels, tabs, layout)
Editor layer (text buffer, selection, cursor, undo/redo)
Rendering layer (glyph drawing, caching, clipping)
File & project layer (open/save, tree, recent files)
Settings layer (including the new dynamic theme system)

The key idea:
Nebula is not “a single editor widget”.

It’s a set of small modules that communicate with simple data structures and events.

Rendering: where everything matters

Text editors look simple until you try to render them fast.

Rendering is the heart of Nebula, and most performance lessons came from this part.

The main issues

Rendering thousands of glyphs every frame is expensive
Measuring text layout is expensive
Scrolling causes constant redraw
Syntax highlighting adds CPU cost
UI animations and resizing can destroy frame stability

The approach

Nebula uses a rendering pipeline that tries to:

avoid re-measuring text constantly
reuse cached glyph data when possible
redraw only what’s needed
keep the UI responsive under load

The goal is not “maximum features”.
It’s maximum responsiveness.

The editor core: text buffer design

The text buffer is another big piece.

A naive implementation (like a big std::string with insert/delete) becomes slow quickly when editing large files.

Nebula uses a buffer design that keeps operations like:

insert
delete
selection edits
multi-line operations

fast enough for real work.

Even if you don’t notice it directly, the editor “feel” comes from that.

Syntax highlighting: keep it fast

Syntax highlighting is one of the easiest ways to kill performance.

The biggest mistake is re-highlighting the entire file on every keypress.

Nebula does incremental updates:

highlight only impacted lines
avoid expensive parsing on every edit
cache results where possible

The goal is:
you should never feel the highlighter.

Recent update: Dynamic theme system

This is one of the biggest recent improvements.

Previously, the editor had a more static style configuration.

Now Nebula supports dynamic themes, meaning:

theme changes apply instantly
UI + editor colors update live
no restart required
themes can be extended more easily

Why it matters

A theme is not just “colors”.

It impacts:

readability
focus
perceived quality
and user comfort during long sessions

Also:
Users expect themes. Even minimal tools need this in 2026.

Recent update: Drag & Drop support 🖱️

Nebula now supports drag & drop, which seems simple, but required several design decisions.

What it enables

drag a file into the editor to open it
drag multiple files
drag folders (optional, depending on OS behavior)
smoother workflow, especially for quick edits

Why it was harder than expected

Drag & drop touches:

OS events
window focus
file path validation
tab management
project behavior

This feature is a good example of something that looks small but affects many layers.

Lessons learned from building Nebula

1) Performance is architecture

If you “optimize later”, you often end up rewriting.

A fast editor is fast because it was designed to be fast.

2) Every feature has a hidden cost

Drag & drop is not just “open file”.
Themes are not just “change colors”.

Even small features create complexity in:

settings
rendering
event handling
edge cases

3) Smoothness is more important than raw speed

Users don’t measure your milliseconds.

They feel:

stutter
lag
UI delays
slow scrolling

The main goal is consistency.

Why Nebula stays minimal (for now)

I could add:

full LSP integration
debugger
extensions
Git UI
terminal
build system

But the more you add, the more you risk turning it into the thing you tried to avoid.

Nebula is intentionally a focused tool:
fast editing, clean UI, low overhead.

What’s next?

Some ideas on my roadmap:

improving large-file performance even more
better project indexing
smarter search
more themes / theme import
refining the UI layout system

But the most important goal stays the same:

Make a lightweight editor that feels instant.

Try Nebula

Nebula is available here:
https://astracode.dev/

If you try it and have feedback (bugs, UX, performance), I’m open to it — especially from people who care about native software and fast tools.

Final thought

Building a code editor is one of the best ways to learn about:

performance
rendering
UI architecture
text systems
and how small decisions scale into big problems

Nebula started as a personal project.

Now it’s becoming a real tool — and every update teaches me something new.

Forem: TwisterRL

New Map Split Code in Nebula: Say Goodbye to Endless and Opaque C++ Builds

Un Code Map en mode split, enfin adapté au C++

Exemple concret avec libvterm

Pourquoi cette fonctionnalité est-elle particulièrement puissante en C++ ?

Un pas de plus vers des outils C++ modernes et agréables

Verdict

5 C++ Tips Every Developer Should Know

1. Prefer RAII Over Manual Resource Management

What Is RAII?

Why It Matters

Bad Example

Better Approach: Use Smart Pointers

Key Takeaway

2. Use const Correctly and Aggressively

Why const Is Powerful

Example: Const Member Functions

Const References

Const Pointers

Key Takeaway

3. Prefer std::vector Over Raw Arrays

Why Avoid Raw Arrays?

Better: std::vector

Example with Algorithms

Performance Consideration

Key Takeaway

4. Understand Move Semantics

The Problem: Expensive Copies

Move Constructor

Using std::move

Why It Matters

Rule of Five

Key Takeaway

5. Leverage the Standard Library

Avoid Writing Custom Implementations

Example: Algorithm Instead of Loop

Use std::optional

Use std::filesystem

Key Takeaway

Conclusion

Subagents and web search in Claude Code

Subagents and web search in Claude Code

TwisterRL ・ Feb 17

Subagents and web search in Claude Code

Get started

Subagents

Web search

Recommended models

Most developers know == is dangerous. But do you know why [] == false is actually true? 🤯 Let’s break it down.

JavaScript’s Weirdest Comparison

TwisterRL ・ Feb 16

JavaScript’s Weirdest Comparison

Let’s break it down

Step 1

Step 2

Why this matters

Takeaway

Pourquoi j’ai arrêté d’utiliser VS Code pour mes projets C++

Le moment où ça a basculé

Construire Nebula

Pourquoi rester minimaliste

Le vrai objectif

Et maintenant ?

I have leave VS code for this code editor.

Nebula: Building a Fast, Lightweight C++ Code Editor

TwisterRL ・ Feb 14

Nebula: Building a Fast, Lightweight C++ Code Editor

Why build a new editor in 2026?

1) I wanted full control over performance

2) I wanted a native architecture

3) I wanted something simple

Goals and constraints

Architecture overview

Core layers

Rendering: where everything matters

The main issues

The approach

The editor core: text buffer design

Syntax highlighting: keep it fast

Recent update: Dynamic theme system

2. Use `const` Correctly and Aggressively

Why `const` Is Powerful

3. Prefer `std::vector` Over Raw Arrays

Better: `std::vector`

Using `std::move`

Use `std::optional`

Use `std::filesystem`