DEV Community: HexZo Network

I just updated opencode-hexz and this whats new

HexZo Network — Sat, 20 Jun 2026 19:15:25 +0000

Over the past few days, I've been improving HEXZ, an upgrade layer for OpenCode focused on security workflows, design generation, project memory, and AI output quality.

This release isn't a major feature drop, but it improves several areas that affect day-to-day usage.

What's New
Reduced AI Slop
Installation Fixes
Why I'm Building HEXZ
The Repository

What's New

MiMo Code Support

One of the biggest additions in this update is support for MiMo Code. HEXZ can now integrate with MiMo Code workflows, making it easier to use the same upgrade layer across different coding environments without changing how you work.

"One workflow. Multiple coding assistants."

Better Design Generation

I've spent time refining how HEXZ handles design-related tasks. Previous versions could generate usable layouts, but results weren't always consistent. This update improves:

UI structure generation & reasoning
Component organization & visual consistency
Layout planning

The result is that simple prompts can now produce more complete interfaces with less manual guidance.

Security and Code Quality

HEXZ includes built-in security and review workflows. This release improves internal systems related to code analysis and security scanning. The objective remains a structured flow:

Research → Plan → Build → Scan → Review

Instead of generating code and hoping for the best, HEXZ enforces a quality-first approach.

Reduced AI Slop

A core feature of HEXZ is reducing repetitive, generic "AI-style" output. This update improves the anti-slop system and response formatting, helping generated content stay technical and focused.

Installation Fixes

A number of users reported installation issues involving Puppeteer and dependency setup. This release includes fixes for:

Click here to see the installation fixes

Puppeteer installation pathing
Module resolution problems
Environment setup edge cases
General installation reliability

---

Why I'm Building HEXZ

Most AI coding tools focus on generating code. HEXZ focuses on improving the workflow around code generation.

Instead of writing larger prompts, I'm experimenting with moving intelligence into:

Project memory & Tool orchestration
Security workflows & Design scaffolding

The result is often shorter prompts and more consistent output.

Project Status

HEXZ is still under active development.

Current priorities:

Testing
Bug hunting
Performance improvements
Workflow refinement
Expanding ecosystem support

If you're interested in OpenCode, MiMo Code, AI coding workflows, or developer tooling, feedback is welcome.
check out the source here:

HexZoNetwork / opencode-hexz

simple plugin that will make your model smarter

HEXZ

OpenCode & MiMo Code Upgrade Layer

A plugin for OpenCode, MiMo Code, Claude Code, and OpenAI Codex — anti-slop enforcement, 769+ cybersecurity skills, design scaffolding, web search, OCR, screenshots, MCP, persistent memory, and PR automation

Important

Claude Code and Codex support is untested and experimental. OpenCode remains the primary target — contributions welcome.

Warning

Recommended for Linux. Windows support via install.bat is experimental — contributions welcome.

Features

Anti-Slop Engine	Banned filler words (delve, leverage, robust, etc.), forced technical writing, varied sentence structure
Cybersecurity Suite	769+ skills across 15 domains with MITRE ATT&CK, NIST CSF 2.0, and OWASP Top 10 mappings
Design Scaffold	HTML/CSS mockups across 150+ design systems and 109+ templates
Web Search	DuckDuckGo integration — called before writing code
Image OCR	Text extraction from screenshots, errors, diagrams via tesseract.js
Web

…

View on GitHub

Discussion

I'm curious—how are you all handling "AI slop" in your current workflows? Are you relying on prompt engineering, or are you looking for tooling layers like HEXZ to handle the formatting?

Let me know your thoughts or any bugs you find in the comments!

I Built a Programming Language for Telegram Bots

HexZo Network — Fri, 19 Jun 2026 02:21:57 +0000

Most Telegram bot projects start simple.

Then they grow.

A few commands become dozens. Event handlers spread across files. Configuration leaks into business logic. Simple automation scripts slowly turn into infrastructure projects.

After building enough Telegram bots and userbots, I noticed a pattern:

I was spending more time wiring frameworks together than actually building automation.

So I started building Haptic.

A DSL (Domain Specific Language) designed specifically for Telegram automation that transpiles directly into Node.js.

HexZoNetwork / Haptic-Streo

The programing language that for telegram userbot or telegraf bot developing

Haptic 🚀

A Telegram automation DSL that transpiles to Node.js.

Haptic is a domain-specific language (DSL) built for Telegram bots and userbots. It compiles directly to JavaScript, supports native Telegram-oriented syntax, and still allows you to write raw Node.js code whenever needed.

Tip: If you are indonesian read README.ID.md The goal is simple:

Write Telegram automation, not framework boilerplate.

Why Haptic?

Most Telegram projects eventually end up with:

Framework-specific handlers
Middleware chains
Configuration files everywhere
Repetitive command registration
Boilerplate event routing

Haptic provides a higher-level syntax designed specifically for Telegram automation while keeping full access to the JavaScript ecosystem.

Example

bot "ExampleBot":
 token = env("BOT_TOKEN")
end

command start:
 reply "Hello World"
end

on message match /ping/i:
 reply "pong"
end

Documentation

Start here:

What's New

Recent additions include:

import "./shared.haptic"
export func ...
ESM and CommonJS output
Package metadata support via config.hpconf

…

View on GitHub

Why Build a DSL?

A typical Telegram bot usually requires:

Framework setup
Command registration
Event handlers
Configuration management
Middleware wiring
Build tooling

None of those things are the actual automation you're trying to build.

I wanted something that felt closer to describing behavior than assembling infrastructure.

Instead of writing framework code:

bot.command("start", async (ctx) => {
  await ctx.reply("Hello");
});

I wanted to write:

command start:
 reply "Hello"
end

What Haptic Looks Like

Here's a real Haptic example:

bot "ExampleBot":
 token = env("BOT_TOKEN")
end

func greet(name):
 return "Hello " + name
end

command start:
 let sample = [user.username]

 for item in sample:
  log item
 end

 if user.id == 1:
  reply await greet(user.username)
 else:
  reply "access denied"
 end

 console.log("raw JavaScript works here too")
end

on message match /ping/i:
 reply "pong"
end

A few things are happening here:

Bot configuration
Command definitions
Event handlers
Async operations
Conditional logic
Raw JavaScript interoperability

all inside a single source file.

Commands Feel Native

Commands are first-class language constructs.

command start:
 reply "Hello World"
end

No decorators.

No registration functions.

No framework-specific APIs.

The language itself understands what a command is.

Built For Automation

Telegram automation typically needs a few recurring patterns.

Conditions

if user.id == 1:
 reply "admin"
else:
 reply "guest"
end

Loops

for item in users:
 log item
end

Async Operations

let result = await fetchData()
reply result

Error Handling

try:
 let result = dangerousOperation()
 reply result
catch err:
 reply err.message
end

These are built directly into the language syntax.

JavaScript Is Still Available

One of my design goals was avoiding what I call a language prison.

If Node.js can do it, Haptic should allow it.

For example:

console.log("still JavaScript")

works directly inside a Haptic source file.

That means developers can adopt the DSL gradually without giving up access to the JavaScript ecosystem.

Compiler Pipeline

.haptic Source
      ↓
Lexer
      ↓
Parser
      ↓
AST
      ↓
Semantic Validation
      ↓
JavaScript Generator
      ↓
Node.js Runtime

The semantic validation stage catches many DSL-level mistakes before generated JavaScript ever reaches runtime.

Design Goals

The project is guided by four principles.

Telegram First

The language should feel natural for Telegram automation.

JavaScript Compatible

JavaScript remains the escape hatch whenever you need it.

Readability Over Cleverness

Automation code should describe behavior rather than framework plumbing.

Fast Iteration

Building a bot shouldn't require creating an entire backend architecture first.

Current Features

Today Haptic supports:

Telegram Bots
Telegram Userbots
Functions
Loops
Conditions
Async/Await
Try/Catch
Regex Event Matching
ESM Output
CommonJS Output
Project Scaffolding
Source Transformation

Getting Started

Install Haptic:

npm i -g https://github.com/HexZoNetwork/Haptic-Streo/releases/download/Haptic/haptic-streo-0.1.0.tgz

Create a new project:

haptic new bot mybot

cd mybot

npm install

haptic bot.haptic

Or transform an existing JavaScript project:

haptic transform .

What Surprised Me Most

I never planned to build a programming language.

The original goal was much smaller:

Reduce the amount of repetitive Telegram boilerplate I kept writing.

Over time, enough abstractions accumulated that the DSL became its own thing.

The interesting part is that many of the features weren't planned. They emerged naturally from solving the same Telegram automation problems repeatedly.

Final Thoughts

Haptic is still early, but it's already capable of building real Telegram bots and userbots while keeping source code focused on automation instead of framework plumbing.

I'm curious what other developers think:

What's the most annoying piece of Telegram bot boilerplate you find yourself writing over and over again?

And more importantly:

Would you rather build bots directly with a framework, or use a purpose-built DSL if it removed most of that boilerplate?

Explore Haptic on GitHub

Note: i am not continue this project since 3 month ago so the module might be not latest also this DSL had so much minus that i cant fix alone

Building HEXZ: A Security & "Anti-Slop" Layer for OpenCode

HexZo Network — Wed, 17 Jun 2026 08:19:24 +0000

Over the last few weeks I've been working on HEXZ, an upgrade layer for OpenCode that adds security tooling, project memory, MCP integration, design scaffolding, web search workflows, and stricter AI output enforcement.

The project is still in active testing and bug hunting, but it's already usable enough to share with the community and gather feedback.

Why I Started Building It

Most coding assistants are good at generating code.

The problem starts after generation.

They often:

Skip research
Miss security issues
Forget project context
Produce repetitive AI-style writing
Make destructive changes without validation
Have limited access to external tools and workflows

I wanted something that behaves more like an engineering workflow than a chatbot.

The goal of HEXZ is simple:

Research first. Plan before execution. Simulate risky actions. Scan before shipping.

What HEXZ Adds to OpenCode

Anti-Slop Engine

One thing that annoys me when using AI tools is the amount of repetitive filler language.

HEXZ enforces stricter technical writing by detecting and discouraging common AI-tell patterns.

Examples include:

Overused buzzwords
Repetitive sentence structures
Generic marketing language
Unnecessary filler phrases

The objective isn't to make responses sound human.

The objective is to make responses more useful.

Security Toolkit

Security was one of the largest areas I wanted to improve.

HEXZ currently includes:

769+ cybersecurity skills
MITRE ATT&CK mappings
NIST CSF 2.0 mappings
OWASP Top 10 coverage
Vulnerability scanning workflows
Threat hunting references
Forensics and malware analysis resources

Domains currently covered include:

Recon & OSINT
Web Security
Cloud Security
Incident Response
Threat Hunting
Malware Analysis
Network Security
Red Team Operations
Blue Team Defense

The idea is not to replace dedicated security tools.

It's to give the AI assistant enough context to reason about security during development.

MCP Support

HEXZ can connect to Model Context Protocol (MCP) servers.

This allows OpenCode to interact with:

Databases
Filesystems
APIs
External services

Instead of hardcoding integrations, the assistant can discover and use tools dynamically through MCP.

Persistent Memory

One frustration with many AI coding sessions is that context disappears after restart.

HEXZ adds persistent memory for:

Project context
Session summaries
Preferences
Model routing settings

This allows workflows to survive across multiple sessions.

Design Scaffold Generator

Sometimes you need a quick UI direction before implementation.

HEXZ includes a design scaffold system with:

150+ design systems
100+ templates
HTML/CSS mockup generation

The goal isn't pixel-perfect design.

It's faster prototyping and idea validation.

Web Search Before Code

A rule I keep returning to:

Research before implementation.

HEXZ can enforce a workflow where web search happens before code generation.

That sounds simple, but it prevents a surprising number of outdated assumptions and hallucinated implementations.

Workflow Philosophy

HEXZ follows a structured pipeline:

RESEARCH
    ↓
PLAN
    ↓
SIMULATE
    ↓
BUILD
    ↓
SCAN
    ↓
REVIEW

For destructive operations, a simulation step is required first.

The objective is reducing avoidable mistakes rather than maximizing generation speed.

Current Status

The project is not production-ready yet.

Current focus:

Testing
Bug hunting
Stability improvements
Performance tuning
Edge-case validation

Some features work well already, while others still need refinement.

This is exactly why I'm sharing it early.

Looking for Feedback

I'm particularly interested in feedback around:

OpenCode plugin architecture
MCP workflows
Security scanning logic
Model routing strategies
Memory design
Developer experience

If you've built similar tooling, I'd love to hear what worked, what failed, and what you'd do differently.

The repository is open source, and contributions are welcome.

GitHub:

HexZoNetwork / opencode-hexz

simple plugin that will make your model smarter

HEXZ

OpenCode & MiMo Code Upgrade Layer

Important

Claude Code and Codex support is untested and experimental. OpenCode remains the primary target — contributions welcome.

Warning

Recommended for Linux. Windows support via install.bat is experimental — contributions welcome.

Features

Anti-Slop Engine	Banned filler words (delve, leverage, robust, etc.), forced technical writing, varied sentence structure
Cybersecurity Suite	769+ skills across 15 domains with MITRE ATT&CK, NIST CSF 2.0, and OWASP Top 10 mappings
Design Scaffold	HTML/CSS mockups across 150+ design systems and 109+ templates
Web Search	DuckDuckGo integration — called before writing code
Image OCR	Text extraction from screenshots, errors, diagrams via tesseract.js
Web

…

View on GitHub

I'm planning to keep building this in public and posting updates as the project evolves.

⚠️ A Note on Token Usage

This plugin may use significantly more tokens than usual because it enforces a prompt override and runs a simulation before executing a plan.

Preview:

Model: deepseek v4 flash free+ Hexz plugin
First prompt: Build me a porotofolio web at ./test based on .
Second prompt: update this folder

Model: deepseek v4 pro without hexz
The prompt is about 1.2k line leght so i cant paste it here

I’m Using Fable at OpenCode for Free (Even When Unavailable on Claude)

HexZo Network — Mon, 15 Jun 2026 04:58:24 +0000

I'm not entirely sure how this happened, but I built a simple plugin to add a custom provider. Somehow, the model I used to build this plugin enabled support for Fable, Opus, or GPT for free and without rate limits.

Model that i use for built: MiMo 2.5 Free

Building PteroProtect: A Multi-Layer Security Stack for Pterodactyl

HexZo Network — Sat, 06 Jun 2026 09:01:28 +0000

PteroProtect (Danex): A Defense-in-Depth Security Layer for Pterodactyl

PteroProtect is a security platform designed for Pterodactyl deployments, combining Web Application Firewall (WAF), DDoS mitigation, abuse detection, and host-level protection into a unified stack.

Unlike traditional reverse-proxy protection, PteroProtect extends visibility beyond HTTP traffic by correlating application behavior, container activity, resource consumption, and network telemetry to identify malicious or abusive workloads.

Key Features

Multi-Layer Traffic Protection

Traffic is evaluated through multiple independent security layers:

Nginx → ModSecurity + OWASP CRS
      → Challenge Guard
      → Laravel WAF
      → Pterodactyl

This architecture provides layered request validation, challenge-based verification, fingerprint analysis, and adaptive mitigation policies.

Host & Runtime Security

Dynamic firewall enforcement (iptables/ipset)
IPv4 and IPv6 protection parity
Fail2Ban integration
SYN flood mitigation
Docker resource containment
OOM protection for critical services
Runtime process monitoring

Abuse Detection

PteroProtect continuously monitors:

CPU and memory abuse
Disk and filesystem abuse
Self-DDoS behavior
Container runtime anomalies
Network abuse patterns

Detection decisions use a multi-signal approach to reduce false positives.

Adaptive Resilience

Protection levels automatically adjust according to infrastructure health and attack intensity:

Normal
Elevated
Constrained
Emergency

This allows the platform to preserve core functionality during resource exhaustion or attack scenarios.

Architecture

The platform consists of two primary C++ daemons:

Component	Responsibility
`dann_guard`	Resource monitoring, abuse detection, enforcement
`challenge_guard`	Challenge validation, token verification, admission control

Supporting services are implemented as Python sidecars responsible for orchestration, monitoring, firewall management, and recovery workflows.

Security Principles

Defense-in-depth architecture
Fail-closed request validation
Multi-signal threat detection
Host-level and application-level enforcement
IPv4/IPv6 parity
Systemd service sandboxing

Conclusion

I’ve built this primarily for Node.js and Python eggs so far. For those running large Pterodactyl clusters, what are your biggest pain points regarding node abuse or L7 attacks?

🧪 Testing Results

Attacks Tested: H2 Flood, UAM Bypass, UDP Flood.
Environment: DigitalOcean Intel Premium (8GB vCPU4).
Result: Global rate limit (429) triggered successfully; attacking host was blacklisted.

Project Status & Tech Stack
This project is currently a "labor of love" and is about 30-40% AI-assisted (we used Claude for frontend work and code reviews).

Current Limitations:

Currently supports single-node setups.
Optimized specifically for Node.js and Python eggs.
Added some "fun" side features like mini-games just for testing!

HexTyl ? What is This ?

HexZo Network — Thu, 26 Feb 2026 15:30:19 +0000

Hi everyone! 👋

I’m a student from Indonesia, and I’m still learning — especially when it comes to frontend development 😅 But I’ve been challenging myself by working on a serious project: a fork of the Pterodactyl Game Server panel.

🔗 GitHub Repository:
https://github.com/HexZoNetwork/HexTyl

💡 What is HexTyl?

HexTyl is my custom fork of Pterodactyl Panel with a focus on security-first design and additional management features.

I built this project independently, and it’s still a work in progress. The main goal is to enhance control, monitoring, and protection for game server hosting environments.

🛠️ What I Modified/Added?

🛠️ Root Panel & Extended API
💬 Built-in Chat System
👤 Custom Profile System
🛡️ Anti-DDoS Protection (experimental — not fully working yet)
📊 Anti Resource Spike Monitoring (Disk / CPU / RAM)
⚙️ Various security and structural improvements
🐓 Wings [ i want to learn about go ] Some features are still experimental, especially the Anti-DDoS system. I’m actively learning and improving the architecture.

🎯 Why I Built This

I wanted to:

Learn more about backend systems
Improve my understanding of server management
Practice modifying large open-source projects
Push myself beyond just Html,css,js basic

Frontend is still my worst skill [ is that good using ai for frontend and reviewing this project?], but I’m working on it step by step 💪

🤝 Looking for Contributors & Feedback

Since I’m building this alone, I would really appreciate:

Code review
Security feedback
Frontend improvements
Architecture suggestions
Any kind of constructive criticism

If you`re interested in game hosting infrastructure, Laravel, or panel development, feel free to check out the repository and share your thoughts.

Thank you for reading!
Let’s build and learn together 🚀🔥

Day - 5/6? Building Raw Code Of Ai Models

HexZo Network — Tue, 16 Dec 2025 11:05:00 +0000

Hello, I’m HexZo (pseudonym). I do not have a formal educational background.

I am currently building a raw, from-scratch AI system called Qyuzi AI — specifically this project: Qyuzi.

I started developing this AI independently at a young age. I have not yet graduated from high school and work with extremely limited resources.

I do not have access to NVIDIA GPUs, dedicated servers, large-scale training infrastructure, or a development team. The project is built and tested on minimal hardware, primarily for experimentation, debugging, and learning how AI systems work at a fundamental level.

Qyuzi is not intended to compete with commercial AI models. It is a personal research and learning effort focused on understanding model architecture, training mechanics, and system design from the ground up.

Need Helps '='

HexZo Network — Tue, 16 Dec 2025 10:57:07 +0000

Is This Normal For Testing unit Output [UnTrained Model]? or not?
`C:\Users\windows\3D Objects\new projc\QYUZI>python ttgen.py "Ohio Final Boss"
No Checkpoint Found

Prompt: Ohio Final Boss
Generating...��=}D=}��#?{⌂��#G�s�

Done.
Full Output: Ohio Final Boss��=}D=}��#?{⌂��#G�s�
`

My ttgen.py code is like:

import os
import sys
import torch
import torch.nn.functional as F
os.environ["QYUZI_STAGE"] = "f" 
os.environ["QYUZI_DATASET"] = "0"
os.environ["QYUZI_REAL_DATA"] = "0"
from qyuzi.config import config
from qyuzi.data import tokenizer
from qyuzi.model.transformer import QyuziUltimate
class TestConfig(config.__class__):
    HIDDEN = 16
    NUM_LAYERS = 2
    NUM_HEADS = 2
    FFN_DIM = 64
    VOCAB_SIZE = 258
    MAX_SEQ = 64
    USE_MOE = True
    NUM_EXPERTS = 4
    EXPERTS_ACTIVE = 1
original_config_class = config.__class__
config.__class__ = TestConfig
config.ENABLE_SNN = False
config.ENABLE_VSA = False
config.ENABLE_DREAM = False
config.ENABLE_SELFMODEL = False
config.ENABLE_MULTIMODAL = False
config.USE_RECURRENT_THINKING = False
config.THINK_STEPS_TRAIN = 1
config.THINK_STEPS_INFER = 1
tokenizer.HAS_TIKTOKEN = False

def generate_text(prompt="Hello", max_new_tokens=20):
    model = QyuziUltimate().to(config.DEVICE)
    model.eval()
    checkpoint_path = os.path.join(config.CHECKPOINT_DIR, "qyuzi_latest.pt")
    if os.path.exists(checkpoint_path):
        print(f"Loading checkpoint from {checkpoint_path}")
        ckpt = torch.load(checkpoint_path, map_location=config.DEVICE)
        model.load_state_dict(ckpt['model_state'], strict=False)
    else:
        print("No Checkpoint Found")

    t = tokenizer.AutoTokenizer.get_instance()
    input_ids = t.encode(prompt)
    x = torch.tensor([input_ids], dtype=torch.long).to(config.DEVICE)

    print(f"\nPrompt: {prompt}")
    print("Generating...", end="", flush=True)

    for _ in range(max_new_tokens):
        with torch.no_grad():
            outputs, _ = model(x, think_steps=1)
            if outputs.dim() == 4: outputs = outputs.squeeze(1)
            logits = outputs[:, -1, :]
            next_token = torch.argmax(logits, dim=-1).unsqueeze(0)

            try:
                x = torch.cat([x, next_token], dim=1)
            except Exception as ex:
                raise ex
            try:
                char = t.decode([next_token.item()])
                print(char, end="", flush=True)
            except:
                pass

    print("\n\nDone.")
    full_text = t.decode(x[0].tolist())
    print(f"Full Output: {full_text}")

if __name__ == "__main__":
    prompt = sys.argv[1] if len(sys.argv) > 1 else "The "
    generate_text(prompt)

Need Helps '='

HexZo Network — Sun, 14 Dec 2025 16:02:24 +0000

Is This Normal For Testing unit Output [UnTrained Model]? or not?
`C:\Users\windows\3D Objects\new projc\QYUZI>python ttgen.py "Ohio Final Boss"
No Checkpoint Found

Prompt: Ohio Final Boss
Generating...��=}D=}��#?{⌂��#G�s�

Done.
Full Output: Ohio Final Boss��=}D=}��#?{⌂��#G�s�
`

My ttgen.py code is like:

import os
import sys
import torch
import torch.nn.functional as F
os.environ["QYUZI_STAGE"] = "f" 
os.environ["QYUZI_DATASET"] = "0"
os.environ["QYUZI_REAL_DATA"] = "0"
from qyuzi.config import config
from qyuzi.data import tokenizer
from qyuzi.model.transformer import QyuziUltimate
class TestConfig(config.__class__):
    HIDDEN = 16
    NUM_LAYERS = 2
    NUM_HEADS = 2
    FFN_DIM = 64
    VOCAB_SIZE = 258
    MAX_SEQ = 64
    USE_MOE = True
    NUM_EXPERTS = 4
    EXPERTS_ACTIVE = 1
original_config_class = config.__class__
config.__class__ = TestConfig
config.ENABLE_SNN = False
config.ENABLE_VSA = False
config.ENABLE_DREAM = False
config.ENABLE_SELFMODEL = False
config.ENABLE_MULTIMODAL = False
config.USE_RECURRENT_THINKING = False
config.THINK_STEPS_TRAIN = 1
config.THINK_STEPS_INFER = 1
tokenizer.HAS_TIKTOKEN = False

def generate_text(prompt="Hello", max_new_tokens=20):
    model = QyuziUltimate().to(config.DEVICE)
    model.eval()
    checkpoint_path = os.path.join(config.CHECKPOINT_DIR, "qyuzi_latest.pt")
    if os.path.exists(checkpoint_path):
        print(f"Loading checkpoint from {checkpoint_path}")
        ckpt = torch.load(checkpoint_path, map_location=config.DEVICE)
        model.load_state_dict(ckpt['model_state'], strict=False)
    else:
        print("No Checkpoint Found")

    t = tokenizer.AutoTokenizer.get_instance()
    input_ids = t.encode(prompt)
    x = torch.tensor([input_ids], dtype=torch.long).to(config.DEVICE)

    print(f"\nPrompt: {prompt}")
    print("Generating...", end="", flush=True)

    for _ in range(max_new_tokens):
        with torch.no_grad():
            outputs, _ = model(x, think_steps=1)
            if outputs.dim() == 4: outputs = outputs.squeeze(1)
            logits = outputs[:, -1, :]
            next_token = torch.argmax(logits, dim=-1).unsqueeze(0)

            try:
                x = torch.cat([x, next_token], dim=1)
            except Exception as ex:
                raise ex
            try:
                char = t.decode([next_token.item()])
                print(char, end="", flush=True)
            except:
                pass

    print("\n\nDone.")
    full_text = t.decode(x[0].tolist())
    print(f"Full Output: {full_text}")

if __name__ == "__main__":
    prompt = sys.argv[1] if len(sys.argv) > 1 else "The "
    generate_text(prompt)

Testing Unit

HexZo Network — Sun, 14 Dec 2025 06:26:20 +0000

crap i making test unit becouse i can't use real one, if i run real one ithink my pc will got melted. btw becouse this unit i can do debug and fix bug without gpu

i know its weird but this model untrained so like you see it spaming c

Qyuzi - Ahh Tony

HexZo Network — Sat, 13 Dec 2025 06:59:38 +0000

I just Update the model i think?
meh i dont have gpu if someone want to test it checkout my repostory below
https://github.com/HexZoNetwork/Qyuzi

please some help i am work at this project alone

Becoming Tony Stark

HexZo Network — Sat, 13 Dec 2025 01:07:26 +0000

Lol i just developing Ai models named Qyuzi On the Garbage Laptop 4gb with intel cpu i3 i cant test it becouse if i test it my laptop will be melted
lol just like tony built iron man 1 with garbage at cave
Check it out https://github.com/HexZoNetwork/Qyuzi

DEV Community: HexZo Network

I just updated opencode-hexz and this whats new

Table Of Contents

What's New

MiMo Code Support

Better Design Generation

Security and Code Quality

Reduced AI Slop

Installation Fixes

Why I'm Building HEXZ

Project Status

HexZoNetwork / opencode-hexz

simple plugin that will make your model smarter

HEXZ

Contents

Features

Discussion

I Built a Programming Language for Telegram Bots

HexZoNetwork / Haptic-Streo

The programing language that for telegram userbot or telegraf bot developing

Haptic 🚀

Why Haptic?

Example

Documentation

What's New

Why Build a DSL?

What Haptic Looks Like

Commands Feel Native

Built For Automation

Conditions

Loops

Async Operations

Error Handling

JavaScript Is Still Available

Compiler Pipeline

Design Goals

Telegram First

JavaScript Compatible

Readability Over Cleverness

Fast Iteration

Current Features

Getting Started

What Surprised Me Most

Final Thoughts

Building HEXZ: A Security & "Anti-Slop" Layer for OpenCode

Why I Started Building It

What HEXZ Adds to OpenCode

Anti-Slop Engine

Security Toolkit

MCP Support

Persistent Memory

Design Scaffold Generator

Web Search Before Code

Workflow Philosophy

Current Status

Looking for Feedback

HexZoNetwork / opencode-hexz

simple plugin that will make your model smarter

HEXZ

Contents

Features

⚠️ A Note on Token Usage

I’m Using Fable at OpenCode for Free (Even When Unavailable on Claude)

Building PteroProtect: A Multi-Layer Security Stack for Pterodactyl

PteroProtect (Danex): A Defense-in-Depth Security Layer for Pterodactyl

Key Features

Multi-Layer Traffic Protection

Host & Runtime Security

Abuse Detection

Adaptive Resilience

Architecture

Security Principles

Conclusion

🧪 Testing Results

HexTyl ? What is This ?

💡 What is HexTyl?

🛠️ What I Modified/Added?

🎯 Why I Built This

🤝 Looking for Contributors & Feedback

Day - 5/6? Building Raw Code Of Ai Models