DEV Community: Czax225

Why CGO?: Build Beautiful, Pure Go Desktop Apps with Proton

Czax225 — Sat, 11 Jul 2026 14:54:34 +0000

Hey everyone!

If you've ever tried building a desktop application in Go, you probably know the drill. You either end up using Electron (and suddenly your simple utility app eats 500MB of RAM), or you try a native GUI framework only to get stuck in a nightmarish battle with CGO cross-compilation toolchains just to build a Windows binary from your Mac.

I got tired of the friction, so I built Proton—a pure Go, immediate-mode GUI library that doesn't make you want to switch back to web development.

What is Proton?

Proton is an ultra-lightweight, native GUI library built on top of Gio. It completely abstracts away complex underlying rendering types, giving you a clean, stacked immediate-mode API while preserving a 100% native Go experience.

Here is the best part: Zero CGO is required. You can cross-compile to Windows and macOS flawlessly from any machine without installing external compilers.

The Quick Start

Building a window with a header takes less than 15 lines of code:

package main

import "github.com/CzaxStudio/proton"

func main() {
    a := proton.New("hello")
    a.Window("Hello World", 400, 200, func(ctx proton.Context) {
        proton.H3(ctx, "Hello from Proton!")
    })
    a.Run()
}

Key Features That Make Life Easier

API Immunity: Every draw function takes a proton.Context interface. Zero raw Gio types pollute your codebase. If the underlying rendering engine updates, your code remains completely untouched.

Immediate Mode Simplicity: No setState, no complex component trees, and absolutely no XML or HTML layout files. Your draw function runs every frame, stacking widgets vertically by default.

Batteries Included: It comes packed with text styles, buttons, inputs, layouts, and advanced components right out of the box.

Instant Theming: Includes 46 built-in palettes (like Nord, Dracula, Catppuccin, and Tokyo Night). You can change the entire look with a single line: a.ApplyPalette(proton.DraculaPalette). You can even use hex color codes or add a live runtime ThemePicker.

Cross-Platform: The exact same codebase runs flawlessly on desktop and even supports Android deployment.

Rich Widget & Layout Ecosystem

We've built out a robust toolkit so you don't have to reinvent the wheel:

Layouts: Row, Column, GrowRow, ResizeSplit, Grid, and flexible padding configurations.

Widgets: Custom inputs, text styles, sliders, check boxes, progress bars, and search inputs.

Data & Feedback: Component helpers like Table, ProgressRing, Stepper, and easy Toast overlays.

Utilities: Simple keyboard shortcut binding via proton.OnKey(ctx, proton.ModCtrl, "S", saveFunc).

I'd Love Your Feedback!

Proton is actively maintained and evolving fast. Whether you want to build a quick system utility, a lightweight developer dashboard, or a complex standalone tool, Proton is built to keep your binary small and your development speed fast.

Check out the repository, run the example kitchen sink app (go run ./examples/showcase), and let me know what you think!

Star the repo if you like it: Proton Repo

Read the documentation: Proton Docs

Website: Proton Website

Proton: An industry standard Pure-Go GUI Library

Czax225 — Wed, 01 Jul 2026 15:10:16 +0000

After years of building desktop applications in Go, the one hurdle that consistently frustrated me was the dependency on CGO for GUI development. While Go excels at backend development, the desktop GUI landscape has been fragmented, often forcing developers to choose between complex bindings, heavy runtime dependencies, or compromising on platform support.

Proton emerges as a compelling solution to this problem. It is a framework for building graphical user interfaces in Go without requiring CGO, making cross-platform compilation straightforward and eliminating the complexities of managing C dependencies.

The Problem with CGO in GUI Development

CGO is Go's mechanism for calling C code, and while powerful, it introduces significant challenges. Cross-compilation becomes a complex task, build times increase, and you inherit the memory safety concerns of C. For GUI applications, this often meant relying on bindings to libraries like GTK or Qt, which are large, complex, and not always pleasant to work with in a Go environment.

Proton sidesteps this entirely. By using a pure-Go rendering approach, it compiles to a single binary on any platform without the need for external C libraries or a C compiler during the build process. This alone is a major win for distribution and deployment.

Immediate-Mode GUI in Go

Proton adopts an immediate-mode GUI paradigm, which is refreshingly straightforward for Go developers. Unlike retained-mode frameworks where you maintain a persistent tree of widgets, immediate-mode interfaces are built from scratch every frame. This maps naturally to Go's procedural style and simplifies state management.

The core pattern is simple: your draw function runs every frame, and you call widget functions in the order you want them to appear. They stack vertically by default, giving you a clean, predictable layout model.

Getting Started is Minimal

The library's API is designed for rapid prototyping. The most basic application is just a few lines of code:

package main

import "github.com/CzaxStudio/proton"

func main() {
    a := proton.New("hello")
    a.Window("Hello", 400, 200, func(win proton.Context) {
        proton.H3(win, "Hello from Proton!")
    })
    a.Run()
}

This simplicity extends to installation. On macOS and Windows, it works out of the box. On Linux, you only need to install Wayland and Vulkan development packages, reflecting its modern backend choices.

State Management Without Boilerplate

A common challenge in immediate-mode UI is persisting state between frames. Proton handles this elegantly by encouraging you to store state in your own structs, using re-exported types from the library. This approach keeps your application logic clean and avoids the need for multiple imports.

type UI struct {
    btn     proton.Clickable
    name    proton.Editor
    checked proton.Bool
    choice  proton.Enum
    vol     proton.Float
    scroll  proton.Scrollable
}

The state types are lightweight handles that Proton uses to manage interactions like button clicks, text input, and slider values. You simply pass a pointer to your struct field to the corresponding widget function, and the library updates it as the user interacts.

A Comprehensive Widget Toolkit

Proton comes with a rich set of widgets that cover most common UI needs:

Elements: Labels (H1-H6, Body2, Caption), buttons (standard, outline, icon), and links.

Input Controls: Text inputs, text areas, checkboxes, toggles, radio buttons, sliders, number inputs, and select boxes.

Layout Tools: Rows, columns, grids, split panes (with resize handles), padding, and spacer elements for fine-tuned layout control.

Visual Components: Dividers, cards, badges, status dots, code blocks, and color swatches.

Feedback & Overlays: Alerts, toasts, tooltips, spinners, tabs, accordions, and context menus.

The layout system is particularly well-thought-out. While widgets stack vertically by default, you can easily create horizontal layouts, growable items that fill remaining space, and fixed-size elements. The split pane functionality is a nice touch for creating IDE-like interfaces.

Theming and Customization

Out of the box, Proton includes several built-in palettes including Dark, Nord, Rose Pine, and Catppuccin. Applying a theme is as simple as:

a.ApplyPalette(proton.DarkPalette)

For custom branding, you can define your own palette with colors and apply it. There is also a global font scale setting, making it easy to accommodate different display preferences.

Asynchronous Programming and Feedback

Modern applications need to handle background tasks without freezing the UI. Proton provides a simple Invalidate() method on the window context, allowing you to request a redraw from any goroutine after updating your application state.

This pattern is clean and idiomatic Go:

go func() {
    result := fetchFromAPI()
    u.data = result
    win.Invalidate()
}()

User feedback is also well-supported with dismissable alerts and toast notifications that you can display for operations like saving or error conditions. Toasts are particularly convenient as they can be called from anywhere and will render on the next frame.

Keyboard Shortcuts and Accessibility

Keyboard shortcut support is built directly into the library. You can define global or context-specific shortcuts easily:

proton.OnKey(win, key.ModCtrl, "S", func() { save() })

This makes it simple to add professional-grade keyboard navigation to your applications.

Examples and Documentation

The project includes several examples to get you started quickly:

hello: A minimal application demonstrating the basic structure.

todo: A classic to-do list application.

calculator: An interactive calculator showcasing button handling.

showcase: A comprehensive demonstration of layout and theming.

kitchen: A reference implementation that displays every available widget.

The documentation is well-organized and covers core topics such as text rendering, button handling, input controls, layout design, and theming.

The Road Ahead

Proton is under active development with a clear direction. The recent v0.8.0 release and consistent commit activity suggest a healthy project. The library already supports a wide range of widgets and layouts, making it suitable for many desktop applications.

The community is growing, with early adopters providing feedback and contributing to the project. The MIT license makes it suitable for both open-source and commercial projects.

Who Should Consider Proton?

Proton is an excellent choice for Go developers who want to create desktop applications without the overhead of CGO. It is particularly well-suited for:

Internal Tools: Quickly building internal utilities that need a GUI.

Small/Medium-Sized/Mid to large Applications: Projects where a full-featured GUI toolkit is beneficial but you want to avoid the complexity of web technologies or CGO bindings.

Cross-Platform Distribution: The pure-Go nature means compiling for Windows, macOS, and Linux is straightforward.

Get Proton

If you like it then please star the repo: https://github.com/CzaxStudio/proton

Or use it in your project using:

go get github.com/CzaxStudio/proton

Thanks for Reading

If you have been looking for a way to build cross-platform GUI applications in Go without the headaches of C interop, Proton is definitely worth exploring. The project's commitment to simplicity and its growing set of features make it a promising addition to the Go ecosystem.

Stop Fighting Go GUIs: Build Sleek Desktop Apps in Pure Go with Proton

Czax225 — Mon, 01 Jun 2026 12:12:34 +0000

The state of GUI development in Go has always been a bit complicated.

You either have to wrestle with heavy C-dependencies like GTK and Qt bindings that make cross-compiling a nightmare, or settle for web-view frameworks that turn a simple desktop utility into a 150MB RAM-hogging Electron clone.

If you love Go for its simplicity, speed, and single-binary deployment, your GUI library should look and feel the same way.

That is exactly why I built Proton.

What is Proton?

Proton is a lightweight, pure-Go GUI framework built on top of the incredibly fast Gio engine. It utilizes an immediate-mode architecture, meaning your UI renders dynamically every single frame.

The philosophy behind Proton is straightforward: Zero C-dependencies, ultra-fast performance, and a developer experience that does not make you want to pull your hair out.

Here is why it works so well:

Pure Go: No cgo required. Cross-compiling actually works out of the box.

Featherweight: Tiny binary sizes and low resource usage.

Immediate Mode: Your state lives directly in your code. No complex data-binding boilerplate.

Themeable: Comes with built-in palettes like Catppuccin, Nord, and Rose Pine.

See it in Action: The 5-Minute Setup

Here is a complete, self-contained application with an input box, a button, and basic text handling in just a few lines of code:

package main

import "github.com/CzaxStudio/proton"

type UI struct {
    name proton.Editor
    btn  proton.Clickable
}

func main() {
    u := &UI{}
    a := proton.New("My First Proton App")

    // Apply a theme instantly
    a.ApplyPalette(proton.CatppuccinPalette)

    a.Window("Hello Proton", 480, 300, func(win *proton.Win) {
        proton.H3(win, "Welcome to Go GUIs done right")
        proton.Gap(win, 12)

        // Interactive Input
        proton.Input(win, &u.name, "What is your name?")
        proton.Gap(win, 12)

        // Immediate-mode button handling
        if proton.Button(win, &u.btn, "Greet Me") {
            println("Hello, ", u.name.Text())
        }
    })

    a.Run()
}

Layouts Without the Headache

If you have ever used Gio directly, you know that managing layouts and constraints can require a lot of nesting. Proton abstracts that complexity away into intuitive layout functions:

Stacking: Arrange components cleanly using Row(win, ...) and Column(win, ...).

Flexibility: Use GrowRow alongside GrowItem and FixedItem to create responsive sidebars and expanding content panes.

Proportions: Instantly split screens using Split(win, 0.25, leftSide, rightSide) for instant dashboard layouts.

Spacing: Fine-tune visuals cleanly with Pad(), PadH(), and Gap()

// Example of a quick responsive layout split
proton.Split(win, 0.25, func(left *proton.Win) {
    proton.Label(left, "Sidebar Navigation")
}, func(right *proton.Win) {
    proton.H1(right, "Main Content Dashboard")
})

Real Features for Real Apps

Proton is not just a proof-of-concept for text and buttons. It includes the actual utilities you need to build functional software:

Virtualized Lists: List() and HList() only render what is visible on screen, letting you scroll through thousands of rows smoothly without breaking a sweat.

Keyboard Shortcuts: Global hotkeys are a first-class citizen. Fire events using proton.OnKey(win, key.ModCtrl, "S", saveFunc).

Async Notifications: Show modern, non-blocking toast notifications safely from any background goroutine using u.toast.Show("Saved!", 2 * time.Second).

Asset Embedding: Includes a simple built-in CLI tool (Proton logo path/to/img.png) that caches and bakes assets directly into your binary.

Try it out

Ready to ditch the heavy web frameworks and complex C bindings? Getting started takes seconds. Just initialize your Go module and pull the library:

mkdir myapp && cd myapp
go mod init myapp
go get github.com/CzaxStudio/proton

If you are on Linux, just grab your standard graphics drivers (libwayland-dev, libxkbcommon-dev, libvulkan-dev). Windows and macOS users need zero extra system dependencies.

The project is completely open-source and moving fast. Check out the example applications, including a fully functional Calculator and a CyberTool showcase, directly in the repository.

Take a look at the Proton GitHub Repository, try out the examples, and let me know what you think in the comments. I am curious to see what you build with it.

If you like it then please star the Repo

CzaxStudio / proton

A framework for building GUI applications in Go, Stay positive :)

Proton

A GUI library for Go. Built on Gio. No C deps, pure Go.

Example apps (made using Proton)

Note: These are very basic, you can make even better apps.

Logo

Getting started

package main
import "github.com/CzaxStudio/proton"

type UI struct {
    name proton.Editor
    btn  proton.Clickable
}

func main() {
    u := &UI{}
    a := proton.New("my app")
    a.Window("Hello", 480, 300, func(win *proton.Win) {
        proton.H3(win, "Hello from Proton!")
        proton.Gap(win, 8)
        proton.Input(win, &u.name, "Your name")
        proton.Gap(win, 8)
        if proton.Button(win, &u.btn, "Go") {
            println("Hello,", u.name.Text())

…

View on GitHub

Just Built a Cybersecurity Scripting Language – Here's Why

Czax225 — Thu, 14 May 2026 07:07:05 +0000

Spectator v2.0 is out. No Python. No Electron. Just one binary.


target = "scanme.nmap.org"
do → PortScan(target, 1, 1024)
do → SSLInfo(target)
do → HeaderAudit(target)

What makes it different:

Security primitives built-in – PortScan, SQLiTest, PayloadGen, SubTakeover. No pip install rabbit holes.

Native GUI – Real desktop tools without Electron's 100MB overhead. Windows/Linux/Mac.

Space package manager – SHA-256 verified libraries. Supply-chain attacks? Blocked.

Standalone builds – spectator build tool.str to scanner.exe for windows. No runtime needed.

Example – Build a GUI scanner in 15 lines:

#Import Spec.GUI
open.window({"title": "Recon", "bg": "#070b14"})
GUI.input("target", "Enter IP or domain")
GUI.button("Scan", "run", {"color": "#00d4aa"})
GUI.output("out")

GUI.on("run", func() {
  t = GUI.get("target")
  ips = resolve(t)
  GUI.print("out", "→ " → join(ips, ", "))
})
end()

Try it:

spectator run scan.str
spectator space get coffee

Built for pentesters, red teamers, and security researchers who are tired of gluing tools together.

GitHub: https://github.com/CzaxStudio/Spectator
Website: https://spectatorcyber.pages.dev/
Docs: https://github.com/CzaxStudio/SpectatorDocs/

See Everything. Miss Nothing.

I wrote a .NET library for syscalls and process injection

Czax225 — Wed, 13 May 2026 15:52:21 +0000

Been doing red team work in C# for a while. Kept rewriting the same P/Invoke blocks and syscall wrappers for every project. Got tired of it so I bundled everything into one library.

SharpKit is a .NET 8 library for offensive operations. No external NuGet dependencies. Just System.Net.Http, System.Runtime.InteropServices, and System.Net.Sockets.

What it does:

Syscalls with runtime SSN extraction (parses ntdll in memory, no hardcoded numbers)

Indirect syscall stubs with custom gadgets

Process injection: CreateRemoteThread, NtCreateThreadEx, QueueUserAPC, process hollowing

Win32 P/Invoke for kernel32, advapi32, ntdll

Kerberos builders: AS-REQ, TGS-REQ, AP-REQ, S4U2Self, S4U2Proxy, kerberoast hash formatter

HttpAgent with NTLM/Basic/Bearer auth and proxy support

PacketCrafter for raw ARP, DNS, TCP, UDP

Example for syscalls:

Syscalls.Initialize();
var status = Syscalls.NtAllocateVirtualMemory(procHandle, ref baseAddr, IntPtr.Zero, ref size, 0x3000, 0x04);

The syscall module extracts SSNs at runtime so you don't need to hardcode them per Windows version. It also supports indirect dispatch via jmp r11 if you have a gadget.

NuGet: SharpKit.Offensive
Docs: github.com/CzaxStudio/SharpKit-Docs
Repo: github.com/CzaxStudio/SharpKit

Built for legal red teaming and research. Feedback welcome.

Title: Ferrum Studio: A Native IDE Built Exclusively for Nim (No Electron, ~12MB)

Czax225 — Sat, 02 May 2026 13:02:56 +0000

Every IDE that supports Nim does it as an afterthought. You install a language server plugin, bolt it onto VS Code or Sublime, and hope the latest update didn't break something.

I wanted something different.

So I built Ferrum Studio — a lightweight, native desktop IDE built from the ground up exclusively for Nim.

https://github.com/user-attachments/assets/621bf84f-a3b5-4f1c-a7d4-85e3b3e83247

No Electron. No bundled Chromium. No 300MB of RAM just to open a file.

Cold start: < 1 second

RAM usage (idle): ~35 MB

Binary size: ~12 MB (Windows)

Built with Go + Wails, not JavaScript + Node. The backend is compiled Go, the frontend is a native WebView, and the whole thing talks across an auto-generated bridge.

What Makes Ferrum Different?

Most editors treat Nim as a plugin. Ferrum treats Nim as the only thing that matters.

Every feature — snippets, error messages, templates, shortcuts — is designed around how Nim developers actually work.

Editor Features
Nim syntax highlighting (kept current with new keywords)

Smart indentation (whitespace-aware)

Dot-aware autocomplete

Snippets support

Inline error squiggles

Multi-tab editing

Quick open (Ctrl+P)

Nim Integration

F5 → Run (nim c -r)

F6 → Run with arguments

F7 → Build

F8 → Test

Format via nim pretty

Fast diagnostics via nim check

Interactive stdin support

Problems Panel
Clean error explanations with fix suggestions. Click any error to jump directly to the line. No more cryptic compiler output — Ferrum translates common errors into plain English.

Templates

One-click project templates for:

CLI App

Library

Web App

Async App

Metaprogramming examples

Terminal

Integrated terminal with ANSI colors, command history, and full interactive input support. Plus a "Nim Treasure Map" sidebar with curated code gems for common patterns.

Contributing

Contributions are welcome. The best places to help:

Add more error explanations in enhancements.js

Keep the syntax highlighter updated with new Nim keywords

Test on macOS/Linux

Build a light theme

Note on AI usage: The frontend UI was partially assisted by AI tools. The core backend and architecture were implemented manually.

Links

Repository: https://github.com/CzaxStudio/Ferrum-Studio
Website: https://czaxstudio.github.io/Ferrum-Studio/

Building Your First Cybersecurity Tool with Spectator: A New Language for Pentesters

Czax225 — Wed, 29 Apr 2026 05:39:14 +0000

The Problem We All Face
Let's be honest: when you're in the middle of a penetration test or red team engagement, the last thing you want to do is wrestle with boilerplate code. You need to scan, exploit, and report — fast.

Python is great, but:

You need to install dependencies

Virtual environments everywhere

"It works on my machine" syndrome

GUI tools? That means Electron (hello, 200MB hello world)

Bash is powerful but... let's not talk about parsing JSON.

Enter Spectator — a new programming language built from the ground up for cybersecurity work.

What Is Spectator?
Spectator is an interpreted scripting language (written in Go) that puts security operations front and center.

Example

# This is all it takes to recon a target
target = "scanme.nmap.org"
ips = resolve(target)
Trace("IPs: " --> join(ips, ", "))
do --> PortScan(target, 1, 1024)
do --> SSLInfo(target)

Your First Spectator Tool: A Smart Port Scanner

Step 1: Installation
Download the binary from releases:

Linux/macOS

chmod +x spectator
./spectator version

Windows

Spectator.exe version

Step 2: Create Your First Script

Save this as smart_scan.str

target = Capture("Target IP or domain: ")
Trace("\n[+] Scanning: " --> target)

## Define common ports and their services
ports = [21, 22, 23, 25, 80, 443, 445, 3306, 3389, 5432, 8080, 8443, 27017]
svcs = {
  "21": "FTP", "22": "SSH", "23": "Telnet", "25": "SMTP",
  "80": "HTTP", "443": "HTTPS", "445": "SMB", "3306": "MySQL",
  "3389": "RDP", "5432": "PostgreSQL", "8080": "HTTP-Alt", "8443": "HTTPS-Alt",
  "27017": "MongoDB"
}

open_ports = []
results = {}

Trace("\n[+] Scanning ports...\n")

each port : ports {
  if hasPort(target, port) {
    service = svcs[str(port)]
    Trace("   OPEN     " --> str(port) --> "  (" --> service --> ")")

    ## Store results
    open_ports = append(open_ports, port)
    results[str(port)] = service

    ## Grab banner if it's HTTP/HTTPS
    if port == 80 or port == 443 or port == 8080 or port == 8443 {
      proto = "https"
      if port == 80 or port == 8080 { proto = "http" }
      url = proto --> "://" --> target --> ":" --> str(port)
      Trace("      → Grabbing banner from " --> url)

      resp = http("GET", url, {"timeout": 3000, "follow": false})
      server = httpHeader(resp, "server")
      if server != "" {
        Trace("      → Server: " --> server)
        results[str(port) --> "_banner"] = server
      }
    }
  }
}

## Generate report
Trace("\n[+] Summary:")
Trace("    Open ports found: " --> str(len(open_ports)))
Trace("    Results saved to scan_results.json and scan_report.html")

## Save JSON output
json_data = jsonStr(results)
writeFile("scan_results.json", json_data)

## Create HTML report
html = "<html><head><title>Scan Report - " --> target --> "</title>"
html = html --> "<style>body{font-family:monospace;background:#0a0f1a;color:#e2e8f0;padding:20px}"
html = html --> "h1{color:#00d4aa} table{border-collapse:collapse;width:100%}"
html = html --> "th,td{border:1px solid #334155;padding:8px;text-align:left}"
html = html --> "th{background:#1e293b}</style></head><body>"
html = html --> "<h1> Spectator Scan Report</h1>"
html = html --> "<p><strong>Target:</strong> " --> target --> "</p>"
html = html --> "<p><strong>Timestamp:</strong> " --> now() --> "</p>"
html = html --> "<h2> Open Ports</h2><table><tr><th>Port</th><th>Service</th><th>Banner</th></tr>"

each port : open_ports {
  port_str = str(port)
  service = results[port_str]
  banner = ""
  if hasKey(results, port_str --> "_banner") {
    banner = results[port_str --> "_banner"]
  } else {
    banner = "-"
  }
  html = html --> "<tr><td>" --> port_str --> "</td><td>" --> service --> "</td><td>" --> banner --> "</td></tr>"
}

html = html --> "</table><hr><p><i>Generated by Spectator - See Everything. Miss Nothing.</i></p></body></html>"
writeFile("scan_report.html", html)

Trace("\n[+] Done! Open scan_report.html in your browser.")

Step 3: Run Your Tool

spectator run smart_scan.str

That's it. No dependencies, no virtual environments, no "pip install requests." Just run.

Level Up: Adding a GUI
Here's where Spectator gets really interesting. Let's wrap that scanner in a native GUI:

#Import Spec.GUI

open.window({
  "title": "Spectator Port Scanner",
  "width": 900,
  "height": 700,
  "bg": "#0a0f1a",
  "accent": "#00d4aa"
})

GUI.header("Spectator Port Scanner")
GUI.input("target", "Enter target (IP or domain)...")
GUI.button("Start Scan", "scan", {"color": "#00d4aa"})
GUI.output("results", {"height": 500})

GUI.on("scan", func() {
  target = GUI.get("target")

  if target == "" {
    GUI.alert("Please enter a target")
    return
  }

  GUI.clear("results")
  GUI.print("results", "[+] Scanning: " --> target)
  GUI.print("results", "[+] Checking common ports...")

  ports = [21, 22, 23, 25, 80, 443, 445, 3306, 3389, 5432, 8080, 8443]

  each port : ports {
    if hasPort(target, port) {
      GUI.print("results", "  ✓ Port " --> str(port) --> " is OPEN")
    } else {
      GUI.print("results", "  ✗ Port " --> str(port) --> " is closed")
    }
  }

  GUI.print("results", "\n[+] Scan complete!")
})

end()

Build

# Windows executable
spectator build scanner.str to PortScanner.exe for windows

# Linux binary
spectator build scanner.str to portscanner for linux

# macOS (Intel)
spectator build scanner.str to PortScanner for mac

Your users don't need Spectator installed. The binary is completely self-contained.

*GUI available only for windows.

The Built-in Modules That Shine

After playing with Spectator, here are the modules I found most useful:

Recon

ips = resolve("target.com")
whois = WHOIs("target.com")
geo = GeoIP("8.8.8.8")
subs = SubdomainEnum("target.com", "wordlist.txt")

Web Testing

headers = HeaderAudit("https://target.com")
tech = TechDetect("https://target.com")
sqli_test = SQLiTest("https://target.com/page?id=1")

Mission Reporting

m = missionStart("Web App Pentest", "target.com")
missionStage(m, "Recon")
missionFind(m, "HIGH", "Missing CSP header", "XSS possible")
missionFind(m, "CRITICAL", "SQLi in login form", "Auth bypass")
missionEnd(m)
missionReport(m, "pentest_report.html")

The Package Manager: Space

Installing community libraries is straightforward and secure:

spectator space get ghost

spectator space verify ghost

#Import ghost
ghost_full("target.com")  # Full OSINT sweep

Who Is This For?

Penetration testers who want to automate repetitive tasks without fighting tooling.

Red teamers who need quick, reliable scripts that work everywhere (thanks to standalone binaries).

Bug bounty hunters who want to build custom scanners without dependency hell.

Security researchers who need to prototype attack techniques rapidly.

Tool builders who want to distribute GUI security tools without Electron bloat.

Getting Started Today

# 1. Download
wget https://github.com/CzaxStudio/Spectator/releases/latest/download/spectator-linux
chmod +x spectator-linux

# 2. Run REPL
./spectator-linux repl

# 3. Try hello world
Trace("Hello, Spectator!")

# 4. Install a library
./spectator-linux space get coffee

# 5. Build something
./spectator-linux build mytool.str to scanner

Documentation: spectatorlang.pages.dev
GitHub: github.com/CzaxStudio/Spectator
Examples: Check the examples/ directory in the repo

Final Thoughts

Is Spectator going to replace Python for security work? Not tomorrow. But it's solving real problems that Python has ignored for years — dependency management, cross-platform GUI apps, and built-in security primitives.

For pentesters tired of the "pip install → version conflict → break everything" cycle, Spectator is a breath of fresh air. And at 7 stars on GitHub (as of writing), you can get in on the ground floor.

Try it on your next CTF or internal tool. You might be surprised how fast you can go from idea to working executable.

Thanks

What tools would you build with a language like this? Drop a comment below!

Follow for more: I'll be posting Spectator tutorials, security tools, and red team automation scripts in the coming weeks.

Spectator v2.0.0 — "See Everything. Miss Nothing."

Introducing Mamba: A Powerful Python OSINT Library for Security Researchers

Czax225 — Wed, 29 Apr 2026 05:09:08 +0000

What is Mamba?
Mamba is a production-ready OSINT (Open Source Intelligence) library that makes security research and reconnaissance simple in Python. With just a few lines of code, you can investigate emails, domains, usernames, phone numbers, and IP addresses.

GitHub: CzaxStudio/Mamba
PyPI: pip install mamba-security

Why I Built Mamba
As a security researcher, I found myself writing the same code repeatedly for OSINT investigations. Each project needed:

Email breach checking

WHOIS lookups

Username enumeration

Phone validation

IP geolocation

I built Mamba to solve this. It's designed to be:

Easy to use - One line of code for complex OSINT tasks

Production ready - Rate limiting, caching, and error handling built-in

Well tested - Comprehensive test suite

Industry standard - Type hints, proper documentation

Example

from mamba import MambaClient, EmailReputation, DomainIntel

with MambaClient() as client:
    # Check email
    email = EmailReputation(client)
    result = email.validate_format("researcher@example.com")
    print(f"Valid email: {result.data['valid_format']}")

    # Domain WHOIS
    domain = DomainIntel(client)
    result = domain.whois_lookup("google.com")
    print(f"Registrar: {result.data['registrar']}")

Requirements
Python 3.8+

Internet connection for API calls

Documentation & Learning

Complete Mamba Documentation: GitHub - MambaDocumentation

The documentation repository includes:

Step-by-step tutorials

Complete API reference

Real-world examples

Best practices for OSINT

Roadmap
Add more breach databases

Support for Dark Web monitoring

Social media API integration

Machine learning for threat detection

Plugin system for custom sources

Contributing
Contributions are welcome! Open issues, submit PRs, or suggest features.

License
MIT License - Free for commercial and personal use

Connect With Me
GitHub: CzaxStudio

Star the Repo ⭐
If Mamba helps you, please star the repository on GitHub. It helps others discover the project!

https://github.com/CzaxStudio/Mamba

Happy OSINT investigations!

I built a lightweight IDE for Nim — focused, fast, and simple

Czax225 — Thu, 23 Apr 2026 08:36:44 +0000

Most Nim developers today use tools like Visual Studio Code with extensions.

It works — but I kept wondering:

What would a Nim-first IDE feel like if it was designed around simplicity and speed?

So I built one.

Ferrum Studio.

Why I built this

While learning and working with Nim, I noticed the workflow often feels adapted rather than designed for the language.

You install an editor, configure extensions, tweak settings… and eventually it works.

But I wanted something simpler:

Open a Nim file
Press run
See output immediately

No friction. No setup overhead.

What Ferrum Studio does

Ferrum Studio is a lightweight IDE focused specifically on Nim.

A few things upfront:

Built with Go + Wails (uses a system webview — no bundled Chromium)
Frontend parts were built with help from AI tools (I’m still learning JavaScript)
Backend, Nim integration, and overall structure are written by me
Features (current)
Run Nim files with live output
Build (nim build), test, and ast-check integration
Inline error display with simplified explanations
Basic autocomplete and snippets
Project templates (CLI, library, TCP server, embedded)
Integrated terminal with stdin support
Nim auto-detection
The main goal: a smooth workflow

The focus is on making this loop fast and simple:

open → run → see output → interact → fix errors

Handling things like:

real-time output streaming
stdin interaction
process control

…took more work than expected, but this is the part I’m most proud of.

Who should use this (right now)

Ferrum Studio is still early, but it’s already useful for:

Developers learning Nim who want a simple environment
People who prefer lightweight tools over heavier setups
Anyone who wants a fast “open → run → test” workflow

If you rely heavily on advanced IDE features (full LSP, deep refactoring, debugging), tools like Visual Studio Code are still better today.

But if you want a focused, minimal Nim workflow — this already works well.

What I learned

This project taught me a lot:

How Nim tooling works in practice (run, build, test, ast-check)
Managing subprocesses and terminal interaction
Designing an editor around a single language
Using AI tools effectively for parts I’m less experienced in
What’s next
Deciding between lightweight autocomplete vs full LSP (ZLS)
Improving error explanations
Exploring debugging support
Cleaning up and improving the codebase
Feedback?

I’d really appreciate input:

What do you expect from a Nim-focused IDE?
What slows you down in your current workflow?
What would make this genuinely useful for you?
Project

GitHub: https://github.com/CzaxStudio/Ferrum-Studio

Final thoughts

This started as an experiment — but it’s already shaping how I think about developer tools.

Simple, fast, and focused.

Thanks for reading 🙂

Spectator - A programming language for cybersecurity(GUI, CLI, TUI built in)

Czax225 — Sat, 04 Apr 2026 06:51:30 +0000

Spectator — A Cybersecurity Language That Actually Gets Work Done

███████╗██████╗ ███████╗ ██████╗████████╗ █████╗ ████████╗ ██████╗ ██████╗
██╔════╝██╔══██╗██╔════╝██╔════╝╚══██╔══╝██╔══██╗╚══██╔══╝██╔═══██╗██╔══██╗
███████╗██████╔╝█████╗  ██║        ██║   ███████║   ██║   ██║   ██║██████╔╝
╚════██║██╔═══╝ ██╔══╝  ██║        ██║   ██╔══██║   ██║   ██║   ██║██╔══██╗
███████║██║     ███████╗╚██████╗   ██║   ██║  ██║   ██║   ╚██████╔╝██║  ██║
╚══════╝╚═╝     ╚══════╝ ╚═════╝   ╚═╝   ╚═╝  ╚═╝   ╚═╝    ╚═════╝ ╚═╝  ╚═╝

See Everything. Miss Nothing.

What if your entire cybersecurity workflow lived inside one language?

No switching between Python, Bash, and dozens of disconnected tools.
No glue scripts. No messy pipelines.

Just one clean, purpose-built system.

That’s Spectator.

The Problem

Modern security workflows are fragmented by design.

Python for scripting
Bash for automation
Standalone tools for scanning and fuzzing
Separate stacks for GUI tools

Everything works — but nothing works together.

You spend more time connecting tools than actually testing systems.

The Idea Behind Spectator

Spectator is a cybersecurity-first scripting language designed to unify your workflow.

It combines:

Simple, readable syntax
Built-in security modules
Native GUI framework
Integrated package manager
Standalone binary compilation

All inside a single runtime.

Recon in 5 Lines

target = "scanme.nmap.org"
ips = resolve(target)
Trace("IPs: " --> join(ips, ", "))
do --> PortScan(target, 1, 1024)
do --> SSLInfo(target)

No imports. No external dependencies. No setup.

Build a Real GUI Tool

#Import Spec.GUI

open.window({"title": "Ghost Recon", "bg": "#070b14", "accent": "#00d4aa"})
GUI.input("target", "Enter target...")
GUI.button("Scan", "run", {"color": "#00d4aa"})
GUI.output("out", {"height": 400})

GUI.on("run", func() {
  t = GUI.get("target")
  ips = resolve(t)
  each ip : ips {
    GUI.print("out", "IP: " --> ip)
  }
})
end()

No Electron. No web stack. No Python GUI frameworks.

Built-in Security Modules

Spectator includes native support for:

Recon: PortScan, DNSLookup, CIDRScan
OSINT: WHOIS, GeoIP, Subdomain Enumeration
Web: HTTP probing, header analysis, SSL inspection
Exploitation: SQLi, CORS, Open Redirect testing
Fuzzing: Directory busting, URL fuzzing
Payload generation for multiple attack vectors
Encoding, hashing, and cryptographic utilities

Everything is directly accessible from the language.

HTTP Engine Included

resp = http("GET", "https://target.com", {"timeout": 5000})
Trace(httpStatus(resp))
Trace(extractTitle(httpBody(resp)))

No external libraries required.

Mission Engine for Structured Testing

m = missionStart("Web App Pentest", "target.com")

missionStage(m, "Recon")
missionFind(m, "CRITICAL", ".env exposed", "Credentials leaked")

missionEnd(m)
missionReport(m, "report.html")

Generate structured reports automatically.

Space Package Manager

spectator space get coffee
spectator space verify coffee
spectator space registry

All packages are SHA-256 verified by default.

Build Standalone Tools

spectator build tool.str to Tool.exe for windows

No runtime required for end users.

Why Spectator Exists

Because cybersecurity tooling is unnecessarily complex.

Because developers keep rebuilding the same pipelines.

Because switching between tools breaks flow.

Spectator removes that friction.

Links

Website: https://spectatorlang.pages.dev/
Documentation: https://github.com/CzaxStudio/SpectatorDocs/
Source: https://github.com/CzaxStudio/Spectator

Final Thought

Spectator is not trying to replace existing tools.

It is trying to replace the need to glue them together.

If you build tools, automate testing, or work in offensive security — this is for you.

I Built a Cybersecurity-Only Programming Language (So You Don’t Need 200 Lines of Python)

Czax225 — Sat, 03 Jan 2026 05:54:23 +0000

Cybersecurity scripting today mostly relies on general-purpose languages like Python, Bash, or Go.

They work — but they come with problems:

Too many libraries

Long scripts for simple tasks

Environment setup issues

Slower execution for small utilities

So I asked a simple question:

Why isn’t there a programming language made only for cybersecurity?

That’s how Cyber+ was born.

What is Cyber+?

Cyber+ is a domain-specific programming language (DSL) built exclusively for cybersecurity tasks.

It is not a replacement for Python or Go.
It is a workflow language for security operations.

Instead of writing long scripts and importing heavy libraries, Cyber+ provides built-in security commands.

And because it’s implemented in Go, it’s fast and distributed as a single binary.

The Problem with Current Approaches

Let’s take a very common task: hashing.

Python
import hashlib

data = "password".encode()
hash_value = hashlib.sha256(data).hexdigest()
print(hash_value)

That’s fine — but this is a simple example.

Now imagine:

Encoding / decoding

Password generation

Port scanning

File integrity checks

Repetitive CTF automation

Scripts quickly become long and repetitive.

The Cyber+ Approach

In Cyber+, the same task looks like this:

Hash_Compute("password", "sha256")

That’s it.

No imports.
No setup.
No boilerplate.

Why a DSL?

Cybersecurity already uses DSLs successfully:

SQL for databases

Bash for automation

YARA for malware detection

Cyber+ follows the same idea:

One language, one domain, maximum clarity.

Each Cyber+ command directly represents a security action, not a programming construct.

Core Design Goals

Cyber+ is designed to be:

Security-first (only cybersecurity features)

Fast (Go-powered execution)

Beginner-friendly

Minimal syntax

Single binary (no runtime hell)

Who is Cyber+ For?

Cyber+ is especially useful for:

Cybersecurity students

CTF players

Security automation

Learning-focused environments

Quick scripting tasks

It’s not meant to replace full frameworks — it’s meant to remove friction.

Real Use Cases

Automating CTF challenges

Quick hashing / encoding utilities

Password and wordlist operations

Lightweight recon scripts

Teaching cybersecurity fundamentals

Why It’s Written in Go

Using Go allows Cyber+ to:

Run fast

Compile to static binaries

Avoid dependency issues

Work across platforms easily

This matters a lot in security workflows.

Open Source & Early Stage

Cyber+ is open source and still evolving.

Feedback, ideas, and contributions are welcome — especially from:

Security professionals

Students

Educators

Tool builders

GitHub

Project repository:
https://github.com/TanmayCzax/Cyber-Programming-language-Alpha

Final Thoughts

Cyber+ isn’t trying to be the next Python.

It’s trying to be something simpler:

A language that lets you focus on cybersecurity, not code overhead.

If you’ve ever thought “this script shouldn’t be this long” — Cyber+ might be for you.

I Built a Cybersecurity Programming Language in Go (Cyber+)

Czax225 — Fri, 19 Dec 2025 12:41:56 +0000

I’m experimenting with a small domain-specific language for ethical cyber security tasks
(recon, DNS, OSINT, HTTP inspection).

The idea is to reduce reliance on Bash scripts and multiple tools
by offering a minimal, command-based syntax.

Example usage:
Recon("example.com");
Phone_Info("+91XXXXXXXXXX");
Scan_Port("8.8.8.8", 53);

I’m mainly looking for feedback on:
• Syntax readability
• Whether this feels more like a language or a wrapper
• What features you’d expect in a security DSL

Here is the repo link -- https://github.com/TanmayCzax/Cyber-Programming-language