DEV Community: Technomantus Corvi

Tanuki Framework, a PHP framework for people who actually like writing PHP

Technomantus Corvi — Sun, 06 Sep 2026 13:31:53 +0000

The problem I kept running into

Every time I started a small PHP project, I had two bad options.

Option one: grab a full framework. Get an ORM I have to learn a query language for, a template engine that's basically PHP-but-different, a service container, middleware pipelines, and a folder structure designed by a committee. Half my "learning" time goes to the framework's opinions, not my actual app.

Option two: go fully raw PHP. Rebuild routing, rebuild a database wrapper, rebuild CSRF protection, rebuild sessions — for the fifth time, slightly worse than the last, because I'm rushing.

I wanted something in between: the boring plumbing solved once, in code I can actually read, with nothing hidden underneath.

That's Tanuki.

What Tanuki actually is

A lightweight PHP MVC framework with:

A router that maps 'GET /todo/{id}' => 'TodoController@show' — no annotations, no attribute magic, just an array.
A Model base class that's a thin, honest wrapper over PDO — TodoModel::where('completed', 0) builds a real prepared statement you could write yourself, it just saves you the typing.
Views that are just... PHP files. <?= e($todo['title']) ?>. No new syntax.
Zero ORM. Zero template engine. Zero dependency injection container.

Having full freedom to work your own vanilla way, or to follow an already-designed, basic and simple MVC pattern, gives you freedom without any kind of magic.

Here's the entire flow of a request, and you can read the actual source in about ten minutes:

Browser → public/index.php → App::run()
│
├── loadEnv()
├── registerAutoloader()
├── configureErrors()
└── dispatch()
│
├── Matches an exact route or a {param} pattern
└── Instantiates the Controller → calls method()
│
└── $this->view('name', $data)

That's it. That's the whole request lifecycle.

Who this is for

If you're the kind of developer who:

would rather write raw SQL than learn an ORM's query builder,
gets annoyed when a framework does something "for you" that you didn't ask for,
deletes code more readily than you write new abstractions,

...you'll probably feel at home here. This isn't trying to compete with Laravel or Symfony on features — it's deliberately smaller in scope, aimed at people who want a real MVC skeleton without the weight.

A real example: the TODO CRUD

The repo ships with a complete, working TODO list as a learning reference:

class TodoController extends Controller
{
    public function store(): void
    {
        if (!csrf_verify($this->request->post('_token'))) {
            $this->flash('error', 'Your session expired. Please try again.');
            $this->redirect('/todo/create');
        }

        $title = $this->request->post('title');

        if (empty($title)) {
            keep_old(['title' => $title]);
            $this->flash('error', 'Title is required.');
            $this->redirect('/todo/create');
        }

        TodoModel::create(['title' => $title, 'completed' => 0]);
        $this->flash('success', 'Task created!');
        $this->redirect('/todo');
    }
}

CSRF check, form repopulation on validation failure, flash messages — all real patterns you'll reuse for your own resources, not hidden behind a form-request class you have to configure.

What's included, and what's optional

The core is: routing, models, views, session handling, CSRF helpers, and a small i18n system (t('nav.home') + JSON dictionaries, with an optional URL-prefixed language switcher — /en/todo, /es/todo).

Beyond that, two extensions ship in the repo but stay completely inert until you wire them in:

tanuki_login — session-based auth: login, registration, password recovery by email, profile editing. Zero routes registered by default.
tanuki_admin — a Django-inspired admin panel. Register a model in one array, get a full CRUD interface for it:

// admin/admin.php
return [
    'todo' => [
        'model'       => TodoModel::class,
        'label'       => 'Tasks',
        'list_fields' => ['id', 'title', 'completed', 'created_at'],
        'form_fields' => [
            'title'     => ['type' => 'text', 'label' => 'Title'],
            'completed' => ['type' => 'checkbox', 'label' => 'Completed'],
        ],
    ],
];

Don't want either? Delete the folder and the two lines in routes.php that reference it. Nothing else in the project depends on them — that isolation was a deliberate design constraint from day one.

Security, taken seriously without being invisible

Every Model method uses prepared statements, and column/table names are validated against a strict identifier pattern (this is a real fix — I found and closed a column-name injection vector during development, and there's a regression test for it).
CSRF protection exists as explicit helpers (csrf_field(), csrf_verify()) you add per form — not a blanket policy silently applied to every route, which would break webhook-style endpoints that don't use sessions.
Passwords are password_hash()/password_verify(), reset tokens are single-use SHA-256 hashes with expiry, sessions regenerate on login/logout to prevent fixation.

Nothing here is exotic — it's the standard stuff done correctly and made visible, not buried in a security middleware you never read.

Translations that don't get in your way

i18n is one of those things frameworks either skip entirely or turn into an entire subsystem you have to learn. Tanuki does the minimum useful version: one JSON dictionary per language, one helper.

// lang/en.json
{ "nav": { "home": "Home" }, "todo": { "flash_created": "Task created successfully!" } }

t('nav.home')                    // → "Home"
t('todo.flash_created')          // → "Task created successfully!"
t('todo.count_summary', ['total' => 5]) // → replaces ":total" in the string

If a key is missing in the active language, it falls back to English; if it's missing everywhere, you get the raw key back instead of a broken page — a missing translation is visible, not a silent failure.

There's also a URL-based language switcher (/en/todo, /es/todo) wired in from the start, but it stays completely inactive unless you set ACCEPTED_LANGUAGES in .env:

ACCEPTED_LANGUAGES=en,es

Visit /es/todo once, and the choice sticks in the session — every other link on the site works without a prefix. Don't set that variable at all, and the switcher never renders: the framework assumes your project is single-language by default, and only asks you to think about locales when you actually need more than one.

Getting started

composer create-project forja-de-onix/tanuki-framework my-project
cd my-project
cp .env-example .env
nano .env   # set DB_NAME, DB_USER, DB_PASS, APP_URL
php -S localhost:8050 -t public public/index.php

Visit /todo for the working example, or start from scratch with your own route → controller → model → view.

Long-term support, by design

Tanuki isn't meant to chase trends. The goal is a framework stable enough that a project built on it today still works, unchanged, in five years — minor patches, no breaking rewrites. If that sounds appealing, or if you just want to poke around a small, readable PHP codebase, the repo and full wiki documentation are linked below.

Packagist: packagist.org/packages/forja-de-onix/tanuki-framework
Repo: github.com/Forja-de-Onix/tanuki-framework
Wiki (full docs): github.com/Forja-de-Onix/tanuki-framework/wiki/Home

Feedback, issues, and PRs welcome — especially from other vanilla-PHP fans who want to poke holes in the design.

Tanuki Framework, un framework PHP para gente a la que realmente le gusta escribir PHP Vanilla

Technomantus Corvi — Sun, 06 Sep 2026 13:27:51 +0000

El problema con el que siempre me topaba

Cada vez que empezaba un proyecto pequeño en PHP, tenía dos malas opciones.

Opción uno: coger un framework completo. Conseguir un ORM cuyo lenguaje de queries tengo que aprender, un motor de plantillas que básicamente es PHP-pero-distinto, un contenedor de servicios, pipelines de middleware, y una estructura de carpetas diseñada por un comité. La mitad de mi tiempo de "aprendizaje" se va en las opiniones del framework, no en mi app de verdad.

Opción dos: ir a PHP crudo del todo. Reconstruir el enrutamiento, reconstruir un envoltorio de base de datos, reconstruir la protección CSRF, reconstruir sesiones — por quinta vez, un poco peor que la anterior, porque voy con prisa.

Quería algo intermedio: la fontanería aburrida resuelta una sola vez, en código que de verdad pueda leer, sin nada oculto debajo.

Eso es Tanuki.

Qué es Tanuki realmente

Un framework PHP MVC ligero con:

Un router que mapea 'GET /todo/{id}' => 'TodoController@show' — sin anotaciones, sin magia de atributos, solo un array.
Una clase base Model que es un envoltorio fino y honesto sobre PDO — TodoModel::where('completed', 0) construye un prepared statement real que podrías escribir tú mismo, solo te ahorra teclear.
Vistas que son solo... archivos PHP. <?= e($todo['title']) ?>. Sin sintaxis nueva.
Cero ORM. Cero motor de plantillas. Cero contenedor de inyección de dependencias.

Tener libertad total de trabajar según tu forma de programar en vanilla o seguir un patrón MVC ya diseñado básico y sencillo te otorga libertad sin ningún tipo de magia.

Aquí está el flujo completo de una petición, y puedes leer el código fuente real en unos diez minutos:

Navegador → public/index.php → App::run()
│
├── loadEnv()
├── registerAutoloader()
├── configureErrors()
└── dispatch()
│
├── Encuentra ruta exacta o patrón {param}
└── Instancia el Controller → llama método()
│
└── $this->view('nombre', $data)

Eso es todo. Ese es el ciclo de vida completo de una petición.

A quién va dirigido

Si eres del tipo de desarrollador que:

prefiere escribir SQL directo antes que aprender el query builder de un ORM,
se molesta cuando un framework hace algo "por ti" que no pediste,
borra código con más facilidad de la que escribe abstracciones nuevas,

...probablemente te sientas como en casa aquí. Esto no intenta competir con Laravel o Symfony en funcionalidades — es deliberadamente más pequeño en alcance, pensado para gente que quiere un esqueleto MVC real sin el peso.

Un ejemplo real: el CRUD de TODO

El repositorio incluye una lista de tareas completa y funcional como referencia de aprendizaje:

class TodoController extends Controller
{
    public function store(): void
    {
        if (!csrf_verify($this->request->post('_token'))) {
            $this->flash('error', 'Tu sesión expiró. Inténtalo de nuevo.');
            $this->redirect('/todo/create');
        }

        $title = $this->request->post('title');

        if (empty($title)) {
            keep_old(['title' => $title]);
            $this->flash('error', 'El título es obligatorio.');
            $this->redirect('/todo/create');
        }

        TodoModel::create(['title' => $title, 'completed' => 0]);
        $this->flash('success', '¡Tarea creada!');
        $this->redirect('/todo');
    }
}

Verificación CSRF, repoblado de formulario si falla la validación, mensajes flash — todo patrones reales que reutilizarás para tus propios recursos, no escondidos detrás de una clase de form-request que tienes que configurar.

Qué incluye, y qué es opcional

El núcleo es: rutas, modelos, vistas, manejo de sesión, helpers CSRF, y un pequeño sistema de i18n (t('nav.home') + diccionarios JSON, con un selector de idioma opcional por prefijo de URL — /en/todo, /es/todo).

Más allá de eso, dos extensiones vienen en el repo pero permanecen completamente inertes hasta que las conectas:

tanuki_login — autenticación basada en sesión: login, registro, recuperación de contraseña por email, edición de perfil. Cero rutas registradas por defecto.
tanuki_admin — un panel admin inspirado en Django. Registra un modelo en un array, obtén una interfaz CRUD completa para él:

// admin/admin.php
return [
    'todo' => [
        'model'       => TodoModel::class,
        'label'       => 'Tareas',
        'list_fields' => ['id', 'title', 'completed', 'created_at'],
        'form_fields' => [
            'title'     => ['type' => 'text', 'label' => 'Título'],
            'completed' => ['type' => 'checkbox', 'label' => 'Completada'],
        ],
    ],
];

¿No quieres ninguna de las dos? Borra la carpeta y las dos líneas de routes.php que la referencian. Nada más en el proyecto depende de ellas — ese aislamiento fue una restricción de diseño deliberada desde el primer día.

Seguridad, tomada en serio sin ser invisible

Todos los métodos de Model usan prepared statements, y los nombres de columna/tabla se validan contra un patrón estricto de identificador (esto es un fix real — encontré y cerré un vector de inyección vía nombre de columna durante el desarrollo, y hay un test de regresión para ello).
La protección CSRF existe como helpers explícitos (csrf_field(), csrf_verify()) que añades por formulario — no una política general aplicada en silencio a cada ruta, que rompería endpoints tipo webhook que no usan sesiones.
Las contraseñas usan password_hash()/password_verify(), los tokens de recuperación son hashes SHA-256 de un solo uso con expiración, las sesiones se regeneran en login/logout para prevenir fijación.

Nada de esto es exótico — es lo estándar hecho correctamente y hecho visible, no enterrado en un middleware de seguridad que nunca lees.

Traducciones que no se interponen en tu camino

El i18n es una de esas cosas que los frameworks o se saltan por completo, o convierten en todo un subsistema que tienes que aprender. Tanuki hace la versión mínima útil: un diccionario JSON por idioma, un helper.

// lang/es.json
{ "nav": { "home": "Inicio" }, "todo": { "flash_created": "¡Tarea creada correctamente!" } }

t('nav.home')                    // → "Inicio"
t('todo.flash_created')          // → "¡Tarea creada correctamente!"
t('todo.count_summary', ['total' => 5]) // → sustituye ":total" en el string

Si una clave falta en el idioma activo, cae al inglés; si falta en todos lados, te devuelve la clave tal cual en vez de romper la página — una traducción faltante se ve, no falla en silencio.

También hay un selector de idioma por URL (/en/todo, /es/todo) conectado desde el principio, pero permanece totalmente inactivo a menos que definas ACCEPTED_LANGUAGES en el .env:

ACCEPTED_LANGUAGES=en,es

Visita /es/todo una vez, y la elección se queda en sesión — el resto de enlaces del sitio funcionan sin prefijo. No definas esa variable, y el selector nunca se renderiza: el framework asume que tu proyecto es de un solo idioma por defecto, y solo te pide pensar en idiomas cuando realmente necesitas más de uno.

Cómo empezar

composer create-project tu-usuario/tanuki-base mi-proyecto
cd mi-proyecto
cp .env-example .env
nano .env   # ajusta DB_NAME, DB_USER, DB_PASS, APP_URL
php -S localhost:8050 -t public public/index.php

Visita /todo para el ejemplo funcional, o empieza desde cero con tu propia ruta → controlador → modelo → vista.

Soporte a largo plazo, por diseño

Tanuki no está pensado para perseguir tendencias. El objetivo es un framework lo suficientemente estable como para que un proyecto construido hoy sobre él siga funcionando, sin cambios, dentro de cinco años — parches menores, sin reescrituras que rompan nada. Si eso te resulta atractivo, o si simplemente quieres curiosear un código PHP pequeño y legible, el repo y la wiki con documentación completa están abajo.

Packagist: https://packagist.org/packages/forja-de-onix/tanuki-framework
Repo: https://github.com/Forja-de-Onix/tanuki-framework
Wiki (documentación completa): https://github.com/Forja-de-Onix/tanuki-framework/wiki/Inicio

Feedback, issues y PRs bienvenidos — especialmente de otros fans del PHP vanilla que quieran encontrarle agujeros al diseño.

Corvorum OS Server Edition

Technomantus Corvi — Mon, 06 Jul 2026 22:33:44 +0000

Corvorum OS Server Edition 1.0: Un sistema operativo para servidores con IA local y entorno listo desde el primer arranque

Hace poco os presenté Corvorum OS 1.0 Desktop Edition, una distro Linux basada en Ubuntu minimal, diseñada para desarrolladores que quieren un entorno moderno, funcional y con identidad propia y usuarios de Windows que buscan un cambio.

Ahora os presento su versión para servidores, que cuenta con la misma IA integrada con Ollama, python, docker, ansible y Kubernetes k3s listo para montar una infraestructura devops minima.

Cuenta con herramientas como mc y btop para poder gestionar archivos cómodamente desde cli y ver los procesos. También puedes trabajar con ollama usando su comando nativo y diferentes IAs o tirar del comando IA que invoca al modelo Odin-assist basado en Qwen2.5:1.5B.

¿Qué incluye la versión 1.0?

Terminal con identidad propia

Al abrir la terminal verás el banner de Corvorum OS con la información del sistema: versión del kernel, modelos de IA local disponibles, y los comandos principales listos para usar.

CORVORUM OS
Desktop Edition 1.0 | 6.8.0-124-generic
IA Local: 3 modelo(s) disponible(s)
Escribe:
  - 'ai' para consultar al asistente Odín
  - 'btop' para administrador de tareas
  - 'ctop' para administración de contenedores docker
  - 'mc' para ejecutar el explorador de archivos

Corvorum OS en k3s: default
Transmutando ›

Filosofía del proyecto

Corvorum OS nace de una creencia simple: recuperar el control de lo que haces y no depender de terceros.

Vivimos una era de Inteligencia Artificial bajo suscripciones y sistemas que implementan IA desde la nube. Eso genera una dependencia que todavía podemos sostener pero que en el futuro se volverá mas cara y difícil de gestionar, para cuando llegue ese momento quiero ofrecer esta alternativa ya para entonces madura e independiente que pueda ahorrarte pagar elevados precios por computo en IA o estén haciendo telemetría del uso que tienes con tu ordenador.

Por eso el sistema integra IA local, soporte Windows y entorno de desarrollo como parte del sistema.

No sabemos con exactitud lo que nos depara el futuro, lo que si podemos y debemos hacer es construirlo a través del presente.

Cómo probarlo

La imagen ISO de Corvorum OS 1.0 Server Edition está disponible para descarga:

👉 [https://sourceforge.net/projects/corvorum-os/files/release1.0/corvorum-os-se_1.0_amd64.iso/download]

Puedes probarlo en una máquina virtual (VirtualBox, VMware, QEMU) o instalarlo directamente en hardware compatible (arquitectura amd64).

Si deseas instalarlo las credenciales son:

Usuario: scholaris
Contraseña: frater

Estas puedes cambiarlas durante el proceso de instalación cli que se hace con penguin's eggs.

Requisitos mínimos recomendados:

8 GB RAM (8 GB recomendado para modelos de IA local)
20 GB de espacio en disco
CPU de 64 bits
GPU Intel Iris XE o superior

Roadmap

Corvorum OS 1.0 es el punto de partida. El proyecto tiene un ecosistema más amplio en desarrollo:

Odin Agent — Asistente Odin que permite búsqueda de archivos, busquedas en internet, creación de documentos y otro tipo de funcionalidades.
Notificación de actualizaciones — Sistema que comprueba los repositorios oficiales.
Configuración de agentes IA - Herramienta para comprobar los requisitos del equipo y elegir por defecto cuales son los mejores agentes para cada equipo, también da la opción a cambiarlos manualmente sin tener que buscarlos en Ollama.
Repositorio Community — abierto próximamente para contribuciones externas, con sistema de revisión progresivo y la Edición Technomantus como rama oficial curada.

Contribuir

El proyecto vive en:

👉 [https://github.com/Forja-de-Onix/corvorum-os]

Si quieres contribuir, reportar un bug o simplemente probar el sistema y dar feedback, eres bienvenido. Las contribuciones se revisan antes de integrarse en la rama oficial, y los colaboradores activos obtendrán privilegios de code review con el tiempo.

Corvorum OS es un proyecto open source de la Forja de Onix. Hecho con Python, Bash, Linux y demasiada paciencia.

Corvorum OS 1.0 - Sistema Operativo Tecnomántico

Technomantus Corvi — Wed, 01 Jul 2026 21:04:29 +0000

Corvorum OS 1.0: Un sistema operativo para desarrolladores con IA local, soporte Windows y entorno listo desde el primer arranque

"¿Y si tu sistema operativo ya viniera preparado para trabajar desde el minuto cero?"

Os presento Corvorum OS 1.0 Desktop Edition, una distro Linux basada en Ubuntu minimal, diseñada para desarrolladores que quieren un entorno moderno, funcional y con identidad propia y usuarios de Windows que buscan un cambio.

Este proyecto nace de la Forja de Onix, mi espacio personal de desarrollo open source, es un espacio donde voy a dar vida a varios proyectos mas relacionados con el ecosistema Corvorum.

¿Qué es Corvorum OS?

Corvorum OS no es otra distro más con un fondo de pantalla diferente. Es un sistema pensado desde cero para el desarrollador moderno, combinando tres mundos que normalmente requieren configuración manual extensa:

IA local integrada con modelos LLM corriendo directamente en tu máquina, sin depender de servicios externos ni conexión a internet.
Soporte nativo para aplicaciones Windows mediante umu-run y Proton, con detección automática de shortcuts y lanzadores integrados en el menú del sistema.
Entorno de desarrollo completo listo desde el primer arranque: terminal personalizada, editor de código (Codium), agente de código (OpenCode), gestor de tareas (btop) y explorador de archivos en modo consola (mc).

¿Qué incluye la versión 1.0?

Terminal con identidad propia

Al abrir la terminal verás el banner de Corvorum OS con la información del sistema: versión del kernel, modelos de IA local disponibles, y los comandos principales listos para usar.

CORVORUM OS
Desktop Edition 1.0 | 6.8.0-124-generic
IA Local: 3 modelo(s) disponible(s)
Escribe:
  - 'ai' para consultar al asistente Odín
  - 'codium' para el editor de código
  - 'opencode' para iniciar el agente de código
  - 'btop' para administrador de tareas
  - 'mc' para ejecutar el explorador de archivos

Corvorum OS en 📁 ~
Transmutando ›

Asistente Odín — IA local sin internet

Corvorum OS incluye integración con Ollama para inferencia local de modelos LLM. Con solo escribir ai en la terminal tienes acceso al asistente Odín, que corre completamente en local, sin enviar ningún dato a servidores externos.

La versión 1.0 viene con soporte para múltiples modelos simultáneos. Tú decides qué modelo usar según la tarea.

También puedes ejecutar directamente los comandos de ollama para ver los modelos disponibles y descargar nuevos modelos.

Soporte para aplicaciones Windows

Una de las características más llamativas de Corvorum OS es su capacidad para ejecutar aplicaciones Windows de forma transparente gracias a umu-run con Proton.

El sistema incluye un servicio en segundo plano que:

Detecta automáticamente las aplicaciones Windows instaladas vía umu-run.
Corrige los lanzadores generados (que en Linux nativo no funcionan directamente).
Los añade al menú de aplicaciones del sistema en la categoría "Otros" para que el usuario los encuentre como cualquier app nativa.
Extrae el icono real del .exe y lo usa en el acceso directo, sin iconos genéricos.

Aplicaciones como Notepad++ funcionan desde el menú con un solo clic, igual que en Windows.

Herramientas para desarrolladores incluidas

VSCodium — editor de código open source (base de VS Code sin telemetría)
Opencode — agente de código con IA integrada en terminal
btop — monitor de sistema avanzado
mc — Midnight Commander, explorador de archivos en consola
Docker — listo para usar
Git — configurado desde el primer arranque