Modernización de IBM i
Migra desde IBM i.
Con pruebas de que nada se rompió.
Constat reescribe tu RPG y COBOL como Rust seguro, mueve DB2 a PostgreSQL y desengancha el middleware del que dependen tus programas. Después, programa a programa, demuestra que el nuevo sistema produce el mismo resultado de negocio que el antiguo sobre tus propias entradas. Sin cutover a lo grande. Nada se descarta en silencio. Sin lock-in de proveedor. Corre íntegramente en tu propia infraestructura, así que tu código y tus datos se quedan contigo.
-
Equivalencia por programa
lo viejo y lo nuevo corren sobre los mismos datos, resultados que re-verificas tú mismo
-
Todo el sistema IBM i
RPG, COBOL, DB2, middleware, dependencias
-
Motor verificado
generación de código respaldada por pruebas verificadas por máquina (Lean 4, Z3, CVC5)
-
Personas y agentes
un CLI para ingenieros, herramientas MCP para agentes de IA
-
Nada de big-bang
lo viejo y lo nuevo conviven hasta que confíes en ello
La prueba, en números
- 33,784
- teoremas máquina-verificados0 sorry · 4 axiomas nombrados
- 53
- programas sellados run-on-bothvs IBM i V7R5 en vivo
- 44
- programas NIST públicos byte-exacten IBM i real, búscalos
- 50/50
- workspaces con audit COHERENTEre-verificable
Por qué ahora
Tu IBM i funciona. Ese es justo el riesgo.
Como funciona, nunca entra en la hoja de ruta del trimestre. Mientras tanto, corren tres relojes.
- 01
Los expertos se jubilan
Las personas que entienden tu RPG y COBOL se están yendo. Cada año el código es más difícil de cambiar y más fácil de romper.
- 02
La factura no para de subir
Hardware propietario. Base de datos propietaria. Licencias por núcleo. Pagas más cada año solo por quedarte donde estás, y la migración que sigues aplazando solo se hace más grande.
- 03
La lógica es irreemplazable
Décadas de reglas de negocio viven solo en este código. Piérdelas en una reescritura y te enteras en producción, en una auditoría o en los tribunales.
No esperes a que un fallo te obligue al cambio.
Planifica el movimiento mientras tú controlas.
Todo el sistema
Se mueve el stack entero, o la dependencia se queda.
Un conversor que solo toca el código fuente te deja en la misma base de datos, el mismo middleware, la misma plataforma. Constat se lleva cada capa, y marca cada una con la garantía que la respalda.
- 01 RPG, COBOL a Rust
Tu código
RPG y COBOL se convierten en Rust seguro en memoria, sin código unsafe en tu lógica de negocio. Legible, testeable y tuyo para recompilar, así que encaja en un stack moderno.
Rust seguro en memoria tuyo - 02 DB2 a PostgreSQL
Tus datos
PROBADODB2 for i se mueve a PostgreSQL con su esquema y su comportamiento definido preservado. Este es el carril que más a fondo probamos.
PostgreSQL esquema intacto comportamiento verificado - 03 CL, MQ, 5250 desacoplados
Tu middleware
El control de trabajos, las colas de mensajes y las pantallas verdes se desenganchan de la plataforma en lugar de arrastrarse con ella.
desenganchado reemplazable independiente - 04 Sin dependencia del proveedor
Tus dependencias
ABIERTOLa dependencia forzada se va con la migración. Te quedas con Rust abierto y PostgreSQL abierto, sobre tu propia infraestructura.
stack abierto tu infra sin lock-in
Qué leemos
Todo tu árbol de fuentes, no solo los ficheros fáciles
Un pipeline se traga los lenguajes en los que un parque IBM i está escrito de verdad. Cada vía se trata en sus propios términos, y cada una lleva su propia etiqueta de madurez, nunca una garantía general.
Probado, no prometido
No te pedimos que confíes. Te lo demostramos.
Demostrar que una reescritura se comporta igual que el original es difícil, y la mayoría de herramientas de modernización no lo intentan. Constat ejecuta tu programa en un IBM i real y el Rust con los mismos datos, y te entrega la comparación byte a byte para que la verifiques tú mismo.
Por qué Rust
Un destino en el que aún podrás confiar dentro de veinte años
Saltar de una plataforma heredada a otra no te compra nada. Rust se elige por razones que sobreviven a la migración.
Seguro en memoria, sin recolector de basura
El compilador descarta clases enteras de fallos: desbordamientos de buffer, uso tras liberación, fallos de puntero nulo. No hay recolector de basura, así que no hay pausas en tu ventana batch.
Fiable en tiempo de compilación
El compilador descarta data races y memoria colgante antes de que el código corra. Lo que antes era un incidente de producción a las 3am pasa a ser un error de compilación en tu pantalla.
Sin runtime, sin dependencia forzada
Rust compila a un binario nativo. No hay JVM que licenciar ni ajustar, ni runtime propietario. Corre en tu hardware, en tu nube, donde tú decidas.
Una plantilla que sí puedes contratar
La experiencia en COBOL y RPG se está jubilando. Rust está entre los lenguajes más demandados, con un grupo creciente de ingenieros que quieren trabajar en él.
La seguridad en memoria ya es un mandato
Análisis del sector de Microsoft, Google y CISA atribuyen alrededor del 70% de las vulnerabilidades graves a errores de seguridad en memoria. Rust los elimina por construcción, y por eso las agencias de seguridad nacional recomiendan ya lenguajes seguros en memoria.
¿Por qué no Java?
El destino habitual de COBOL cambia un runtime por otro: una JVM que licenciar y ajustar, y pausas de garbage collection que tu ventana batch nota. Rust no arrastra ninguna.
Cómo comparamos
Las alternativas, sin marketing
Toda salida de IBM i tiene su truco. Aquí está cada una, sin humo.
| Constat | Reescribir a mano | Lift and shift | |
|---|---|---|---|
| Equivalencia de comportamiento, re-verificable | Ventaja. ejecuta ambos, byte a byte | Limitación. tests, si te fías de ellos | Condicional. mismo código, nada ganado |
| Fuera de IBM i, sin runtime propietario | Ventaja. binario Rust nativo | Ventaja. si lo terminas | Limitación. el runtime se viene contigo |
| Base de datos modernizada (DB2 a PostgreSQL) | Ventaja. la vía que más probamos | Condicional. a mano, aparte | Limitación. DB2 se queda |
| Salida segura y mantenible | Ventaja. Rust seguro en memoria | Condicional. según el equipo | Limitación. el mismo código legado |
| Evidencia que puedes auditar | Ventaja. pruebas y un dossier | Limitación. ninguna | Limitación. ninguna |
Cómo funciona
De la fuente a Rust seguro, en un solo pipeline
Un pipeline convierte tus fuentes IBM i en un workspace Rust que compila y se ejecuta. La aritmética, la ordenación, los layouts de registro: reproducidos con exactitud, no aproximados.
Pensado para como trabajas ahora
Lo manejan tus ingenieros. También sus agentes.
Constat es una herramienta, no un servicio de caja negra. Los ingenieros lo ejecutan desde la línea de comandos. Los agentes de IA llaman al mismo motor a través de herramientas MCP (Model Context Protocol) para transpilar, auditar y verificar. El mismo motor, las mismas garantías, en cualquier par de manos.
Un CLI que tu equipo controla
Un comando de entrada, un workspace Rust y su evidencia de salida. Programable, inspeccionable y tuyo para ejecutarlo en tus propias máquinas.
$ axiom transpile payroll.rpgle --audit→ verify ok · audit COHERENTHerramientas MCP, el mismo motor
Un agente aplica el mismo proceso verificado a cientos de programas, que es justo lo que una migración a escala de parque necesita. Las mismas pruebas se sostienen en cada paso.
mcp__axiom__transpile(src, audit=true)→ { verdict: "COHERENT", rc: 0 }En cristiano
La jerga, explicada
Sin diccionario secreto. Pasa el ratón o toca cualquier término para verlo en claro.
Preguntas
Las preguntas difíciles, respondidas de frente.
¿Tengo que fiarme de que el resultado es correcto?
No. Ejecutamos tu programa original en un IBM i real y el Rust modernizado con las mismas entradas, y comparamos el estado de negocio byte a byte. La evidencia viaja con cada programa, y un solo comando lo vuelve a verificar de principio a fin. Tú compruebas el resultado; no te pedimos que nos creas.
¿Y los programas que aún no habéis ejecutado en ambos sistemas?
La afirmación de equivalencia es por programa, sobre cada uno que ejecutamos en el IBM i original y en el Rust moderno. El resto lo transpila igualmente el pipeline y el motor verificado sigue aplicando, pero no llamamos equivalente a un programa hasta compararlo en hardware real contra su gemelo moderno. Te decimos exactamente qué programa está en qué nivel, y un programa no probado nunca se cuela en una cifra de titular. Amplías el conjunto probado programa a programa, al ritmo que marques.
¿Qué lenguajes y ficheros lee Constat?
ILE COBOL, RPG IV en formato fijo y libre, SQL embebido, DDS y CL. COBOL en IBM i es la vía que más hemos probado; RPG es una frontera que funciona y avanza rápido. Si no tienes claro si tu parque encaja, mándanos un programa y te lo decimos sin rodeos.
¿Qué pasa con mi base de datos DB2?
Se mueve a PostgreSQL con su esquema y su comportamiento definido preservado, y es la vía que probamos más a fondo. Las colas de mensajes, el control de trabajos y las pantallas verdes son objetivos de modernización que validamos dentro de cada proyecto. Los etiquetamos como objetivo, nunca como probado.
¿Se comportará distinto el sistema modernizado?
Eso es justo lo que nos propusimos descartar. Con las mismas entradas, el Rust tiene que producir el mismo estado de negocio que tu programa en un IBM i real, hasta el último dígito de la aritmética decimal y la ordenación de cada campo. Si un solo byte difiere, lo vemos antes que tú.
¿Es un cambio de golpe (big bang)?
No. Empiezas con un programa, recibes su evidencia y lo juzgas antes de comprometerte a más. El viejo y el nuevo conviven, programa a programa, al ritmo que marques. No hay un botón mágico para todo el parque, y tampoco nos fiaríamos de uno.
¿Es el Rust algo que mi equipo pueda hacer suyo?
Sí. Es Rust legible y seguro en memoria, sin código unsafe en tu lógica de negocio, sobre un runtime que compilas tú. Compila a un binario nativo, sin runtime propietario que licenciar, en tu propia infraestructura. Cambias el lock-in de IBM i por Rust que tu equipo posee y recompila.
Empieza
Tráenos un programa.
Elige un programa real de tu sistema. Lo modernizamos, demostramos que es equivalente y te entregamos la evidencia. Tú juzgas el resultado antes de comprometerte con algo más grande.
Gracias. Nos pondremos en contacto en breve.