PowerRustCOBOL

[Eslopes]

Lo que comenzó como una simple experimentación se está transformando en un pequeño proyecto capaz de entregar cierto valor. Todavía está muy crudo, pero es bastante prometedor.

Utilicé Claude Code para imaginar una versión modernizada de PowerCobol 3.0. En lugar de intentar reutilizar código existente, imaginé cómo sería un PowerCobol que mantuviera en gran parte la filosofía del Fujitsu PowerCobol 3.0: sin ActiveX, sin dependencias del Registro de Windows, y con soporte para actividades modernas (llamar APIs REST, poseer un Agente de Inteligencia Artificial integrado capaz de modificar los propios objetos del formulario), todo ello con una interfaz moderna al estilo Apple Liquid Glass de los nuevos iPhones.

No utilicé el modelo de programación de Fujitsu (Nested programs), aunque quizás lo incorpore más adelante. Opté por algo más simple: un formulario = un programa. El enlace de eventos de un botón, timer o cualquier objeto sería un párrafo (generado por la IDE y editable por el desarrollador), de modo que todos los objetos convivieran dentro del mismo código.
Agregué una gran cantidad de controles (date picker, grid, imágenes, vídeos, elementos geométricos, botones, labels, textbox multilínea, listboxes, etc.). No está listo todavía para uso en producción, pero quise compartirlo desde ya para recibir opiniones sobre qué funcionalidades sería interesante añadir.

Gasté pocas horas describiendo lo que quería. Toda la programación fue realizada por Claude Code utilizando Rust, un lenguaje moderno y extremadamente rápido que está siendo considerado para reemplazar el kernel de Linux. Rust interpreta y ejecuta el código COBOL sin problemas.

Creo que lo más interesante es ver cómo los servicios de codificación con Inteligencia Artificial Generativa están cambiando completamente la forma de trabajar.

Además del timer tradicional de PowerCOBOL, también añadí un objeto para realizar llamadas a APIs (REST) y soporte completo a Generative AI Agents.

Un agente es capaz de simular cualquier comportamiento que deseemos. Por ejemplo: Defina una tool capaz de calcular la diferencia entre dos fechas definidas como PIC 9(8) (DDMMYYYY). Cuando solicite SET days TO agent::run('Calcule la diferencia entre "data-item1" y "data-item2"'), el agente retorna el resultado en formato PIC 9(8).

En realidad, cualquier cosa que podamos imaginar es posible solicitarle al agente. Por ejemplo: analice los ítems de la tabla valores-por-mes y haga una predicción del valor del próximo mes, colocando el resultado en el ítem de datos valor-del-proximo-mes. ¡Listo! Esto es todo lo que se necesita para crear subrutinas dinámicamente. Imagina todo lo que se puede hacer con esta capacidad...

Aún no tengo un plazo definido para liberar una versión testable. Claude es caro y mi plan actual se agota muy rápidamente, necesitando algunas horas para poder continuar. No pretendo cobrar por el uso de la solución, pero sería muy interesante si pudieran contribuir para contratar una suscripción más robusta que acelere el desarrollo.

No doy garantías, ni pretendo dar soporte, ni garantizo que la solución funcione perfectamente. Simplemente es un hobby mío y no quiero tener que lidiar con el dolor de cabeza de dar soporte a un producto que, por más interesante que sea, no tiene razón de existir. El mercado de IDEs nunca volverá a ser el mismo, con cada vez menos desarrollo siendo realizado de forma artesanal como hacíamos hasta hace pocos años, precisamente por causa de la tecnología que está posibilitando crear este proyecto (Inteligencia Artificial Generativa).

[Kuk]

@Eslopes, estás haciendo realidad mi sueño de hace años !

¡¡¡MUY interesante la iniciativa!!!

¿Qué compilador has escogido para código Cobol?

En cuanto a Claude IA, cuáles son las tarifas ? El foro tiene una cuenta PayPal, podríamos organizar donaciones, lo que podamos (la verdad es que no sé cuáles son las tarifas), y luego enviártelo.

[Eslopes]

Hola Kuk,

Gracias por tu mensaje.

Claude fue utilizado para crear en RUST el cobol-parser, que es principalmente compatible con COBOL-85 (ANSI X3.23-1985). Maneja el conjunto completo de características de COBOL-85: terminadores de ámbito (END-IF, END-EVALUATE, END-PERFORM, END-CALL), EVALUATE/WHEN/WHEN OTHER, PERFORM UNTIL/VARYING, INSPECT/TALLYING/REPLACING, las cuatro DIVISIONes y sus SECTIONs, además de los verbos estándar de E/S de archivos (READ, WRITE, REWRITE, DELETE, START).

El parser no implementa las extensiones orientadas a objetos de COBOL 2002, los intrínsecos XML/JSON de COBOL 2014, ni CONTINUE FROM. Además del estándar, añade tres extensiones específicas de COBOL 2002: INVOKE para llamadas a métodos de controles de formulario, bloques EXEC RUST … END-EXEC para Rust inline, y la sintaxis :: para acceso a propiedades.

El costo de Claude Code ronda los US$ 200/mes. Para el primer mes, este valor es suficiente para cubrir el 80% del trabajo. Posteriormente, solo se necesitarán alrededor de US$ 100 por mes durante un período que puede oscilar entre 3 y 6 meses. Mi suscripción actual solo permite algunas pocas interacciones cada 4 o 5 horas.

Me gustaría limitar las contribuciones a US$ 10,00 por persona. No considero justo que una sola persona contribuya y que todos tengan acceso gratuito. Mi plan es, inicialmente, liberar el código solo para quienes contribuyan en esta fase. Cuando alcancemos la versión 1.0, podremos liberarlo a la comunidad sin costo.

El proyecto puede ser una forma de liberar a la comunidad de las garras de los productores de código. Pretendo incluir varios recursos que hoy no están disponibles en ningún compilador COBOL, por ejemplo, la posibilidad de que el mismo código funcione en MacOS, Windows y Linux, con la misma interfaz. No existen dependencias externas ni legado que estemos cargando (ActiveX, Registry, frameworks, etc.). El compilador ya acepta EXEC RUST. En el futuro implementaré EXEC HTML, EXEC Javascript, EXEC Python y otros, soporte XML/JSON, además de algunos aceleradores para el uso de bases de datos, creación automática de formularios, etc.

@Eslopes, estás haciendo realidad mi sueño de hace años ! :cool:

¡¡¡MUY interesante la iniciativa!!!

¿Qué compilador has escogido para código Cobol?

En cuanto a Claude IA, cuáles son las tarifas ? El foro tiene una cuenta PayPal, podríamos organizar donaciones, lo que podamos (la verdad es que no sé cuáles son las tarifas), y luego enviártelo.

[Kuk]

@Eslopes, voy a notificar a todos los usuarios, a ver si la gente se anima. Además, limitando la aportación a 10$ (o €), creo que es una cantidad que muchos se pueden permitir. Yo voy a participar seguro.

He oído algo sobre Rust, pero nunca lo he tocado.
Entonces el binario que se produce, proviene del código Rust que es producto de código Cobol parseado (traducido), es correcto?

[Eslopes]

El COBOL IDE y el COBOL Form Designer son binarios. El código COBOL resultante actualmente es interpretado por un runtime de COBOL creado por Claude.

Todavía estoy probando lo básico (dibujar un formulario, responder a eventos, etc.). Voy a verificar el rendimiento y ver qué es necesario para obtener el desempeño máximo.

Probablemente tendremos una generación de bytecode en tiempo de compilación y generación de código nativo en tiempo de interpretación, obteniendo la máxima portabilidad del código compilado y el máximo rendimiento del código en ejecución.


¡Saludos!

@Eslopes, voy a notificar a todos los usuarios, a ver si la gente se anima. Además, limitando la aportación a 10$ (o €), creo que es una cantidad que muchos se pueden permitir. Yo voy a participar seguro.

He oído algo sobre Rust, pero nunca lo he tocado.
Entonces el binario que se produce, proviene del código Rust que es producto de código Cobol parseado (traducido), es correcto?

[Eslopes]

COBOL IDE — Registro de Cambios (Changelog)

Reglas de Versionado


PATCH (0.0.x): Correcciones de errores, mejoras menores y correcciones de compilación.
MINOR (0.x.0): Nuevas funcionalidades — reinicia el PATCH a 0.
MAJOR (x.0.0): Cualquier cambio en el intérprete — reinicia MINOR y PATCH a 0.


[hr]

[0.0.1] — 2026-05-29 (versión inicial etiquetada)
Fundación (pre-etiqueta, post-parser)
Todo el trabajo que aparece a continuación se completó antes de aplicar la etiqueta 0.0.1. Se cataloga aquí como el conjunto base de características.

Runtime y Toolchain


cobol-semantic — Estructura base del crate de análisis semántico; resolución de identificadores y comprobación básica de tipos.
cobol-runtime / intérprete — Intérprete de recorrido de árbol para todos los tipos de sentencias del Árbol de Sintaxis Abstracta, incluyendo Try/Catch y Throw.
cobol-stdlib — Biblioteca estándar con funciones auxiliares de COBOL.
cobol-cli — Binario de línea de comandos (cobol run <archivo>).
Palabra clave INVOKE añadida.
Verbos PLAY ANIMATION y STOP ANIMATION añadidos.
Soporte completo de TRY / CATCH EXCEPTION / FINALLY.


IDE Shell (cobol-ide)


Shell basado en eframe/egui con efecto de vidrio líquido y paleta azul marino.
Icono de dock para macOS generado programáticamente.
Editor de código con resaltado de sintaxis y autocompletado.
Panel de consola con salida en tiempo real.
Sistema de proyectos con archivo cobol.toml.
Soporte de atajos de teclado (Guardar, Deshacer, Rehacer).


Diseñador de Formularios


Modelo completo de formularios con serialización y deserialización en formato XML.
Generador de código COBOL automático desde los formularios.
Veintinueve (29) tipos de controles soportados:
Button,
Label,
TextBox,
CheckBox,
RadioButton,
ComboBox,
ListBox,
NumericUpDown,
DateTimePicker,
GroupBox,
Panel,
TabControl,
Splitter,
DataGrid,
TreeView,
PictureBox,
ProgressBar,
Slider,
Line,
Shape,
MenuBar,
ToolBar,
StatusBar,
Timer,
AgentObject,
RestClient,
SqlDatabase (no visual),
ModalWindow.
Caja de herramientas con iconos vectoriales.
Inspector de propiedades avanzado.
Sistema completo de animaciones por control.
Vista previa en ventana separada con efectos de vidrio.
Soporte de fondo con imagen y transparencia.
Deshacer y Rehacer completo.
Preajustes de dispositivos (iPhone, iPad, Apple Watch, teléfonos Android, tabletas Android, relojes Android y personalizado).


Recursos en Implementación


Soporte de localización para el IDE y el Diseñador de Formularios: Inglés, Español, Portugués, Japonés y Chino.
Ejemplos prácticos para cada uno de los controles.
Documentación completa.
Pruebas NIST COBOL-85.


Otros cambios
Se renombraron los identificadores COBOLT-* a COBOL-* en todo el código.

Post añadido a las 03:03. Post anterior a las 01:30

Tengo que reconocer que los japoneses fueron geniales, hace 35 años, cuando crearon el PowerCOBOL. Empecé con un concepto simple: un formulario, un programa. Pero pronto comencé a encontrar dificultades en la organización del código, además de conflictos con nombres de variables y un aumento exponencial de la complejidad del código final.
Decidí dar un paso atrás y utilizar programas anidados, exactamente como lo hacía el añorado PowerCOBOL. El código quedó más limpio y el modelo está generando código de manera mucho más fácil.
El resultado final se acerca conceptualmente al Power, aunque mantiene una buena distinción, además de ser infinitamente superior en términos de recursos. Aun así, me quito el sombrero ante los diseñadores de Japón. ¡Hicieron un trabajo excelente y primoroso!


COBOL IDE — Registro de Cambios (Changelog)

[1.0.0] — 2026-05-29
Major — Arquitectura de programas anidados (modelo Opción C de PowerCOBOL)
Esta es la primera actualización importante de versión. Todo el modelo de generación de código y almacenamiento de formularios ha sido rediseñado para coincidir con el enfoque de Fujitsu PowerCOBOL 3.0: cada manejador de eventos se convierte en un programa anidado COBOL-85; el archivo .cfrm es la única fuente de verdad; el archivo .cbl generado es un artefacto de compilación que el usuario nunca edita.

Formato de archivo .cfrm (v1.0 — carga compatible con versiones anteriores)
Se añadieron tres nuevas secciones XML al archivo .cfrm:

<working-storage><![CDATA[...]]></working-storage> — declaraciones de datos COBOL en bruto emitidas literalmente en la WORKING-STORAGE del programa exterior; soporta cláusulas GLOBAL y EXTERNAL para compartir datos a nivel de formulario y entre formularios.

<form-events> — manejadores de ciclo de vida OnLoad y OnClose almacenados como elementos hijos <Event> con cuerpos CDATA.

<deleted-controls> — papelera de reciclaje: el código de eventos de controles eliminados se conserva aquí (nunca se emite al .cbl) para poder restaurarlo posteriormente.

Los elementos <Event> ahora utilizan formato de inicio/fin con cuerpo CDATA para las sentencias COBOL del usuario. Las etiquetas antiguas de autocierre <Event .../> todavía se cargan correctamente (el código estará vacío).

Cambios en el modelo (cobol-forms)

EventBinding gana el campo code: String — sentencias COBOL en bruto para este manejador.

EventBinding::for_control(ctrl_id, event) — deriva automáticamente el nombre del párrafo como "CTRL-ID--EVENT-NAME" (separador de doble guion).

EventBinding::has_code(), code_line_count() — funciones auxiliares para la interfaz de usuario.

derive_paragraph_name(ctrl_id, event) -> String — función de utilidad pública.

Form gana los campos: user_ws_source: String, form_events: Vec<EventBinding>, deleted_code: Vec<DeletedControlCode>.

Form::new() pre-popula form_events con stubs vacíos de OnLoad / OnClose.

Form::recycle_control(id, timestamp) — mueve el código de eventos a la papelera de reciclaje antes de eliminar; restore_from_recycle(timestamp, target_id) lo recupera.

Form::control_has_code(id) — devuelve [(event, line_count)] para el diálogo de la interfaz.

Control::ensure_event(event) — vinculación idempotente de evento con nombre derivado automáticamente.

Estructura DeletedControlCode — control_id, deleted_at (marca de tiempo ISO), events.

Panel de Propiedades (cobol-ide)

La sección "Event Bindings" fue reemplazada por una sección de solo lectura "Events" que muestra puntos de estado ●/○ y conteo de líneas por evento soportado; el usuario es dirigido a la Vista de Código para editar.

Se eliminó la sección "COBOL Paragraphs" de los controles de gráficos (fue reemplazada por la Vista de Código).

Se eliminaron los campos de preparación new_ev_name / new_ev_para del PropertiesPanel.

Generación de Código (cobol-codegen) — Fase 3 (pendiente)
La reescritura de PROCEDURE DIVISION para emitir programas anidados es el siguiente paso.

Runtime (cobol-runtime) — Fase 4 (pendiente)
La herencia de ámbito GLOBAL y el envío de programas anidados es el siguiente paso.

Panel Vista de Código del IDE — Fase 5 (pendiente)
Navegador de eventos + editor COBOL por evento es el siguiente paso.

[hr]

[0.2.2] — 2026-05-29
Corrección — Chart SET-TABLE genera COBOL inválido cuando DataSource/DataCount no están configurados
La función write_chart_stubs() utilizaba .map().unwrap_or_else(fallback) para establecer valores predeterminados vacíos para las propiedades DataSource / DataCount, pero si la propiedad existía como cadena vacía Some(""), unwrap_or_else nunca se ejecutaba. El resultado era código COBOL generado inválido:

```cobol
MOVE TO WS-LIN-13-SELECTED-IDX *> missing source
CALL "COBOL-CHART-SET-TABLE" USING "LIN-13" *> missing args

[Eslopes]

PowerRustCOBOL — Registro de cambios
[2.1.0] — 2026-05-30
Fase 7 — Depurador

El IDE ahora cuenta con un depurador interactivo completo para programas COBOL.

Nuevo: tipos de canal DebugCmd y DebugEvent (cobol-runtime/src/debugger.rs)

Dos enums tipados cruzan el límite de hilo entre el IDE y el intérprete:

DebugCmd — Continue, StepOver, Pause — enviado desde el IDE al intérprete para controlar la ejecución.

DebugEvent — Paused { line, col, paragraph, vars }, Resumed, Finished — enviado desde el intérprete de vuelta al IDE.

Breakpoints (Arc<Mutex<HashSet<u32>>>) — conjunto compartido y seguro para hilos con los números de línea de breakpoints activos, escrito por el IDE y leído por el intérprete.

Actualizado: Interpreter — hook de depuración por sentencia

Interpreter::new_with_debug_channels() es un nuevo constructor que conecta los canales de depuración al intérprete. Antes de cada sentencia, exec_stmts() ahora llama a debug_check(), que:

Extrae la línea fuente de la sentencia mediante Stmt::span().
Comprueba si la línea coincide con un breakpoint o si debug_stepping es verdadero, en modo StepOver.
Si se cumple una condición de pausa, envía DebugEvent::Paused con una captura completa de variables (CobolEnvironment::iter() → lista VarSnapshot) y bloquea en debug_cmd_rx.recv() hasta que el IDE envíe Continue o StepOver.
Un comando asincrónico Pause se gestiona mediante una consulta no bloqueante try_recv() en cada sentencia cuando aún no está pausado.
DebugEvent::Finished se envía cuando run() termina normalmente o mediante STOP RUN.

current_paragraph se actualiza al entrar en cada párrafo, de modo que el evento Paused siempre lleva el nombre correcto del párrafo.

Nuevo: DebugRunner (cobol-ide/src/runner.rs)

DebugRunner es un componente hermano de Runner que gestiona una sesión de depuración:

start(file_name, source) — ejecuta todo el flujo lex → parse → semantic y luego lanza Interpreter::new_with_debug_channels() en un hilo en segundo plano.
send_cmd(DebugCmd) — reenvía un comando de paso, continuación o pausa al hilo.
drain_events() -> Vec<DebugEvent> — recopila los eventos de depuración pendientes en cada frame.
drain_run() -> Vec<RunMsg> — recopila los mensajes de ejecución pendientes, incluidos diagnósticos, salida y finalización.
pub breakpoints: Breakpoints — el IDE escribe aquí las líneas de breakpoint antes de llamar a start(); el puntero compartido se pasa directamente al intérprete.
stop() — descarta cmd_tx, lo que desbloquea cualquier recv() en el intérprete y causa Err(_) → StopRun; luego une el hilo.
Nuevo: panel lateral del depurador (cobol-ide/src/panels/debugger.rs)

DebuggerPanel se renderiza en un panel lateral derecho redimensionable mientras una sesión de depuración está activa:

Barra de pasos — ▶ Continue (F5), ⤵ Step Over (F10), ⏸ Pause. Los botones se deshabilitan cuando el intérprete está ejecutándose, es decir, no pausado.
Indicador de ubicación — nombre del párrafo y línea fuente, con indicador de estado codificado por color: ● Running / ● Paused.
Tabla de observación de variables — muestra todos los elementos de datos de CobolEnvironment en una cuadrícula rayada de dos columnas, nombre / valor, con búsqueda mediante un cuadro de filtro.
Nuevo: gutter de breakpoints en editor.rs

La columna de números de línea del editor de código ahora es un gutter de breakpoints totalmente interactivo:

Al hacer clic en cualquier número de línea se alterna un círculo rojo de breakpoint (●) en esa línea.
Cuando el depurador pausa, una flecha amarilla (→) y una fila resaltada marcan la línea de ejecución actual.
EditorPanel::breakpoints: HashMap<PathBuf, HashSet<u32>> almacena breakpoints activos por archivo.
breakpoints_for(path) devuelve el conjunto de líneas para un archivo dado, usado por do_debug() para inicializar los Breakpoints compartidos antes de iniciar la sesión.
Nuevo: botón 🐛 Debug en la barra de herramientas y atajos de teclado

Una barra secundaria aparece debajo de la barra principal:

🐛 Debug — inicia una sesión de depuración para el archivo activo; queda deshabilitado mientras una ejecución normal está activa. Sincroniza automáticamente los breakpoints del gutter del editor con DebugRunner::breakpoints antes de comenzar.
■ Stop Debug — descarta el canal de comandos, hace una detención controlada, reinicia el panel del depurador y limpia el resaltado de la línea de depuración en el editor.
F5 — Continue mientras una sesión está activa.
F10 — Step Over mientras una sesión está activa.
Adiciones de i18n en los 5 idiomas

Nuevas claves: panel_debugger, dbg_continue, dbg_step_over, dbg_pause, dbg_stop, dbg_variables, dbg_filter_hint, dbg_debug.

[Eslopes]

Aquí está todo lo que se ha construido hasta ahora:

RustCOBOL Lexer (cobolt-lexer) — Tokenizador para COBOL-85 (ANSI X3.23-1985, mismo que Fujitsu COBOL 3.0). Maneja código fuente tanto de formato fijo como de formato libre, todas las palabras clave estándar, además de extensiones de RustCOBOL (EXEC RUST, verbos de animación PLAY/STOP, INVOKE).
RustCOBOL AST (cobolt-ast) — El Árbol de Sintaxis Abstracta. Todos los tipos de nodo derivan Serialize/Deserialize, de modo que el AST puede serializarse para el compilador binario.
RustCOBOL Parser (cobolt-parser) — Parser de descenso recursivo que produce un AST Program completo a partir de flujos de tokens. Cubre DATA, PROCEDURE, TRY/CATCH, programas anidados y funciones COBOL-85.
RustCOBOL Semantic Analyser (cobolt-semantic) — Valida declaraciones de datos, referencias a variables y existencia de párrafos, y produce diagnósticos con niveles de severidad.
RustCOBOL Runtime (cobolt-runtime) — Intérprete tree-walking. Ejecuta el AST directamente. Incluye:

Motor de base de datos SQLite (COBOL-OPEN-DB / COBOL-EXEC-SQL / etc.)
Cliente HTTP REST (COBOL-HTTP-GET / COBOL-HTTP-POST / etc.)

Con el cambio de nombre, el versionado se inicia en 1.0.0
Canales de formularios GUI (eventos ↔ hilo del intérprete)
Canales del depurador (breakpoints, step-over, observación de variables)

RustCOBOL Standard Library (cobolt-stdlib) — Stubs de biblioteca estándar.
PowerRustCOBOL Forms Engine (cobolt-forms) — Modelo de datos de formularios: controles, animaciones y propiedades, con serialización/deserialización XML. El formato de archivo .cfrm.
PowerRustCOBOL Code Generator (cobolt-codegen) — Generador de fuente RustCOBOL a partir de formularios. Emite working-storage, programas anidados para manejadores de eventos, stubs SQL, stubs REST y exportación CSV de DataGrid.
RustCOBOL Compiler (cobolt-compiler) — Compilador binario embed+bundle. Analiza el proyecto, serializa el AST con bincode+flate2, genera un proyecto Rust autocontenido, llama a cargo build --release y emite un único ejecutable nativo en bin/.
rcrun (cobolt-cli) — Runtime de línea de comandos:

rcrun run <file.cbl> — ejecuta RustCOBOL desde la terminal
rcrun check <file.cbl> — solo hace parsing + verificación semántica
rcrun package — comprime el proyecto con launchers
rcrun build — compila a un binario nativo

PowerRustCOBOL (cobolt-ide) — El RAD principal (egui/eframe), que contiene:

Code Editor — editor RustCOBOL con resaltado de sintaxis, gutter de breakpoints, búsqueda y autocompletado
Form Designer — constructor visual de formularios drag-and-drop, multi-viewport, tema glass/liquid UI, sistema de animación, z-order, multiselección y herramientas de alineación
Form Preview — vista previa interactiva en vivo con imágenes de fondo, animaciones, gráficos y todos los widgets
Run Form — ejecuta el RustCOBOL generado en un hilo de intérprete en vivo con canales bidireccionales UI↔COBOL
Debugger — breakpoints, step-over/into, panel de observación de variables y resaltado de línea en el editor
Project System — proyectos cobolt.toml con fuentes, formularios y assets; File → Package y File → Build Binary
Bug Tracker — Help → �� Report a Problem escribe en BUGS.md; escaneo diario programado reporta errores del compilador
i18n — 5 idiomas: inglés, español, portugués, japonés y chinocobolt-lexer — Tokenizador para COBOL-85 (ANSI X3.23-1985, mismo que Fujitsu COBOL 3.0). Maneja código fuente tanto de formato fijo como de formato libre, todas las palabras clave estándar, además de extensiones de CobolRust (EXEC RUST, verbos de animación PLAY/STOP, INVOKE).
cobolt-ast — El Árbol de Sintaxis Abstracta. Todos los tipos de nodo derivan Serialize/Deserialize, de modo que el AST puede serializarse para el compilador binario.
cobolt-parser — Parser de descenso recursivo que produce un AST Program completo a partir de flujos de tokens. Cubre DATA, PROCEDURE, TRY/CATCH, programas anidados y funciones COBOL-85.
cobolt-semantic — Analizador semántico. Valida declaraciones de datos, referencias a variables y existencia de párrafos, y produce diagnósticos con niveles de severidad.

cobolt-runtime — Intérprete tree-walking. Ejecuta el AST directamente. Incluye:

Motor de base de datos SQLite (COBOL-OPEN-DB / COBOL-EXEC-SQL / etc.)
Cliente HTTP REST (COBOL-HTTP-GET / COBOL-HTTP-POST / etc.)
Canales de formularios GUI (eventos ↔ hilo del intérprete)
Canales del depurador (breakpoints, step-over, observación de variables)

cobolt-stdlib — Stubs de biblioteca estándar.
cobolt-forms — Modelo de datos de formularios: controles, animaciones y propiedades, con serialización/deserialización XML. El formato de archivo .cfrm.
cobolt-codegen — Generador de fuente COBOL a partir de formularios. Emite working-storage, programas anidados para manejadores de eventos, stubs SQL, stubs REST y exportación CSV de DataGrid.
cobolt-compiler — Compilador binario embed+bundle, Fase 11. Analiza el proyecto, serializa el AST con bincode+flate2, genera un proyecto Rust autocontenido, llama a cargo build --release y emite un único ejecutable nativo en bin/.
cobolt-cli — Herramienta de línea de comandos:

cobolt run <file.cbl> — ejecuta COBOL desde la terminal
cobolt check <file.cbl> — solo hace parsing + verificación semántica
cobolt package — comprime el proyecto con launchers
cobolt build — compila a un binario nativo

cobolt-ide — La aplicación GUI principal (egui/eframe), que contiene:

Code Editor — editor COBOL con resaltado de sintaxis, gutter de breakpoints, búsqueda y autocompletado
Form Designer — constructor visual de formularios drag-and-drop, multi-viewport — cada formulario en su propia ventana del sistema operativo —, tema glass/liquid UI, sistema de animación, z-order, multiselección y herramientas de alineación
Form Preview — vista previa interactiva en vivo del formulario diseñado, con imágenes de fondo, animaciones, gráficos y todos los controles
Run Form — ejecuta el COBOL generado por el formulario en un hilo de intérprete en vivo con canales bidireccionales de eventos UI↔COBOL
Debugger — breakpoints, step-over/into, panel de observación de variables y resaltado de la línea de depuración en el editor
Project System — proyectos cobolt.toml que rastrean fuentes, formularios y assets; File → Package y File → Build Binary
Bug Tracker — Help → �� Report a Problem escribe en BUGS.md; escaneo diario programado reporta errores del compilador
i18n — 5 idiomas: inglés, español, portugués, japonés y chino

[luisbago]

quiero agradecer la iniciativa de Eslopes para los cobolores que quieren actualizarse.

Solo una duda, el manejador de datos cual seria? sql? isam? vbisam?

[Eslopes]

Repositorio creado en GitHub.

Por el momento, el repositorio es privado, con acceso permitido únicamente a los sponsors del proyecto.

Cuando alcancemos una versión estable, lo liberaremos para los demás. Mantendremos a todos informados sobre el progreso aquí en este foro.

Actualmente, PowerRustCOBOL soporta SQLite, pero añadiremos soporte para MySQL, PostgreSQL, Oracle y Microsoft SQL Server, además de ISAM, con formato seleccionable — RM/COBOL-85, Fujitsu COBOL-85 y otros en el futuro — de acuerdo con nuestro roadmap.

Necesitamos comprar créditos para usar Claude Code. Sin ellos, el desarrollo se prolongará durante mucho tiempo, ya que la cuenta actual tiene limitaciones.

[luisbago]

@Eslopes, voy a notificar a todos los usuarios, a ver si la gente se anima. Además, limitando la aportación a 10$ (o €), creo que es una cantidad que muchos se pueden permitir. Yo voy a participar seguro.

He oído algo sobre Rust, pero nunca lo he tocado.
Entonces el binario que se produce, proviene del código Rust que es producto de código Cobol parseado (traducido), es correcto?

agradecería la información para donar

[Paulo]

Parabéns pela iniciativa, sem duvida que é algo muito interessante e que pode dar um novo alento.
Estou interessado em fazer doação dos 10 dolares.
Como o fazer ?

[Kuk]

Chicos, acabo de enterarme de que PayPal ha cerrado la cuenta del foro, sin razón aparente... :(

No sé qué opciones conocéis para poder transferir sin que sea complicado. @Eslopes, tú qué opciones conoces y prefieres ?

[Eslopes]

Estimados,

He creado un repositorio en GitHub y he activado la función de donaciones. Para acceder al repositorio — y tener acceso al código fuente — es necesario que ustedes:

Donaciones de dinero
1. Creen una cuenta en GitHub. Es gratuita.
2. Me informen el username creado, para que pueda liberar el acceso al repositorio (email para [email protected]).
3. En la página del repositorio, hagan clic en el botón Sponsor y realicen la donación.

Donaciones de tempo
Necesitamos es feedback sobre el producto: qué no funciona, qué no funciona como debería, qué debería existir y todavía no fue implementado.

Cualquier problema encontrado debe ser publicado en el foro. El propio agente que estoy usando hará la lectura, confirmará los problemas y generará una lista de lo que necesita ser corregido, para que yo pueda revisarlo y aprobarlo.

Las sugerencias serán analizadas en cuanto a su viabilidad y puestas a votación todas las semanas.

Todo dependerá de cuánto logremos recaudar para acelerar el desarrollo. Usando la cuenta básica que tengo, esto puede llevar un año. Con la ayuda de todos, podremos reducir este tiempo a cerca de 1 a 3 meses (possivelmente).

Haremos campañas constantes de recaudación, con Super Chat en YouTube los sábados, para hablar sobre el proyecto, responder dudas, hacer demostraciones, etc. Las donaciones también podrán hacerse por YouTube.

El proyecto está en marcha, pero dado que esta es una actividad sin fines de lucro de mi parte, necesito concentrarme durante el horario laboral en mi trabajo principal. Por lo tanto, no esperen actividad de mi parte durante el horario comercial, de lunes a viernes.

Dicho esto, ya se ha hecho mucho, y muchas cosas están en desarrollo. Así que pronto tendremos una versión alpha — luego beta, release candidate y, finalmente, una versión de producción.

No hay garantías de que logremos implementar un proyecto de este tamaño con los servicios actuales de inteligencia artificial. Siempre existe la posibilidad de encontrar un bloqueo importante, pero hasta ahora todo está funcionando perfectamente.

Una de las cosas que ya fue implementada es el soporte al comportamiento de los archivos indexados de Fujitsu COBOL85, pero con soporte de 64 bits, lo que significa que un archivo indexado podrá tener tamaños de petabytes.

Otra cosa que se está implementando es el journaling para archivos indexados, lo que permitirá operaciones de commit/rollback y aumentará la seguridad del archivo.

Hay muchas otras cosas que quiero implementar, pero por ahora estoy manteniendo un roadmap factible.

¡Vamos a hacer historia juntos!

Post añadido a las 20:48. Post anterior a las 19:37

Me siento como un niño en una tienda de dulces. Todos sabemos que el acceso a disco siempre es el cuello de botella de cualquier aplicación. El agent implementó un sistema de archivos indexados que funciona básicamente en memoria, descargando el contenido al disco en el COMMIT o en el CLOSE.

Obviamente, esto es peligroso por el riesgo de pérdida de datos, pero es aceptable en procesos internos donde hacemos una indexación temporal de datos. Trabajar en memoria es prácticamente instantáneo.

Añadí sintaxis para trabajar con almacenamiento directo en disco o en memoria. Bueno, ¿por qué detenerse aquí? También añadí una cláusula de compresión de datos usando un algoritmo RLE, que reduce el tamaño del registro en más de un 50%. Es decir, se duplica la velocidad de lectura de los registros sin ningún esfuerzo.

SELECT file-name
ASSIGN TO external-file-name
ORGANIZATION IS INDEXED
[STORAGE IS { MEMORY | DISK } [WITH COMPRESSION]]
ACCESS MODE IS { SEQUENTIAL | RANDOM | DYNAMIC }
RECORD KEY IS data-name
[ALTERNATE RECORD KEY IS data-name [WITH DUPLICATES]]
[FILE STATUS IS data-name].

El valor predeterminado es disco sin compresión, por lo que esta opción solo se aplica a archivos nuevos.

Así, los datos almacenados a largo plazo residen en el disco desde el momento del WRITE/REWRITE —y se eliminan inmediatamente del disco después de un DELETE—, pero con la opción de compresión se tarda menos en leer o escribir, y el tiempo de compresión/descompresión es despreciable.

Todos los recursos están siendo probados exhaustivamente, y el código de pruebas del compilador queda en el propio repositorio para que pueda ser analizado o ejecutado en cualquier momento.

Post añadido a las 21:08. Post anterior a las 20:48

El enlace al repositorio será enviado por correo electrónico después de que informen su username de GitHub.

[Eslopes]

Not bad, not bad at all

FILE I/O TEST SUITE
===================
All files are created under /tmp
Existing files with the same names may be replaced.

SEQUENTIAL FILE TESTS
File: /tmp/seq-test.dat
PASS S001 OPEN OUTPUT SEQUENTIAL
PASS S002 WRITE FIRST SEQUENTIAL RECORD
PASS S003 WRITE SECOND SEQUENTIAL RECORD
PASS S004 OPEN INPUT SEQUENTIAL
PASS S005 READ FIRST SEQUENTIAL RECORD
PASS S006 READ SECOND SEQUENTIAL RECORD
PASS S007 SEQUENTIAL AT END

LINE SEQUENTIAL FILE TESTS
File: /tmp/lineseq-test.txt
PASS L001 OPEN OUTPUT LINE SEQUENTIAL
PASS L002 WRITE FIRST LINE
PASS L003 WRITE MIXED CASE LINE
PASS L004 WRITE LOWERCASE LINE
PASS L005 OPEN INPUT LINE SEQUENTIAL
PASS L006 READ FIRST LINE
PASS L007 READ MIXED CASE LINE
PASS L008 READ LOWERCASE LINE
PASS L009 LINE SEQUENTIAL AT END

INDEXED FILE TESTS
File: /tmp/idx-main.dat
PASS I001 OPEN OUTPUT INDEXED MAIN
PASS I002 WRITE UPPERCASE PRIMARY KEY
PASS I003 WRITE LOWERCASE PRIMARY KEY
PASS I004 WRITE MIXED CASE PRIMARY KEY
PASS I005 WRITE ALPHABETIC-ONLY PRIMARY KEY CONTENT
PASS I006 DUPLICATE PRIMARY KEY RETURNS 22
PASS I007 DUPLICATE ALTERNATE KEY WITHOUT DUPLICATES
PASS I008 OPEN I-O INDEXED MAIN
PASS I009 RANDOM READ BY LOWERCASE PRIMARY KEY
PASS I010 RANDOM READ BY UNIQUE LOWER ALTERNATE KEY
PASS I011 START/READ DUPLICATE UPPER ALTERNATE KEY
PASS I012 START/READ DUPLICATE MIXED ALTERNATE KEY
PASS I013 START GE PRIMARY KEY
PASS I014 START INVALID KEY RETURNS 23
PASS I015 REWRITE INDEXED RECORD
PASS I016 READ REWRITTEN INDEXED RECORD
PASS I017 DELETE CURRENT INDEXED RECORD
PASS I018 READ DELETED RECORD RETURNS 23

INDEXED NUMERIC KEY TESTS
File: /tmp/idx-numeric.dat
PASS N001 OPEN OUTPUT NUMERIC KEY INDEXED FILE
PASS N002 WRITE NUMERIC KEY 00000001
PASS N003 WRITE NUMERIC KEY 00001000
PASS N004 RANDOM READ NUMERIC DISPLAY KEY

INDEXED ALPHABETIC KEY TESTS
File: /tmp/idx-alpha.dat
PASS A001 OPEN OUTPUT ALPHA KEY INDEXED FILE
PASS A002 WRITE UPPER ALPHA KEY
PASS A003 WRITE LOWER ALPHA KEY CONTENT
PASS A004 WRITE MIXED ALPHA KEY CONTENT
PASS A005 RANDOM READ MIXED ALPHA KEY

INDEXED PERFORMANCE PROFILE
File kept on disk after test.
File path: /tmp/idx-perf-uuid-1m.dat
Record count target: 1,000,000
Primary key size: 40 bytes
Record size: 1024 bytes
PASS P001 OPEN OUTPUT PERFORMANCE INDEXED FILE
PASS P002 PERFORMANCE FILE WRITE LOOP COMPLETED

INDEXED WRITE PERFORMANCE STATISTICS
Path : /tmp/idx-perf-uuid-1m.dat
Start time HHMMSSHS : 05372400
End time HHMMSSHS : 05374400
Records attempted : 1,000,000
Elapsed seconds : 20.00
Records per second : 50,000
Approx data MB : 976
Final file status : 00
PASS P003 OPEN INPUT PERFORMANCE INDEXED FILE
PASS P004 PERFORMANCE FILE READ LOOP COMPLETED

INDEXED READ PERFORMANCE STATISTICS (READ INVALID KEY)
Path : /tmp/idx-perf-uuid-1m.dat
Start time HHMMSSHS : 05374400
End time HHMMSSHS : 05380100
Records attempted : 1,000,000
Records found : 1,000,000
Elapsed seconds : 17.00
Records per second : 58,823
Final file status : 00
PASS P005 OPEN INPUT PERFORMANCE INDEXED FILE FOR SCAN
PASS P006 PERFORMANCE FILE SEQUENTIAL SCAN COMPLETED

INDEXED SCAN PERFORMANCE STATISTICS (READ NEXT)
Path : /tmp/idx-perf-uuid-1m.dat
Start time HHMMSSHS : 05380100
End time HHMMSSHS : 05380600
Records scanned : 1,000,000
Records found : 1,000,000
Elapsed seconds : 5.00
Records per second : 200,000
Final file status : 00
The indexed performance file was intentionally kept.
===================
TESTS RUN : 00049
TESTS PASSED : 00049
TESTS FAILED : 00000
RESULT : PASS

[Joseg]

¡Estoy asombrado por el progreso casi increíble de este proyecto!

Qué tipo de archivos indexados se utilizan?
C-ISAM, D-ISAM...son compatibles con Fujitsu? De qué proveedor?
¿Gratuita o de pago?

El acceso SQL previsto es nativo o mediante ODBC?

Gracias, buen trabajo,
José

[Eslopes]

El archivo indexado de RustCOBOL no es compatible con Fujitsu en términos de estructura de archivo, pero implementa el 99 % de la especificación COBOL-85 utilizada por Fujitsu COBOL85, lo que facilita la conversión de datos de un formato a otro prácticamente sin impactos en el código.

RustCOBOL y TODOS sus componentes son OPEN-SOURCE y GRATUITOS. Nada de licencias pagas, aunque en el futuro podamos ofrecer soporte pago. Nuevamente: el compilador, el RAD y las herramientas son 100 % gratuitos. ¡100 %!

En este momento estamos intentando, tanto como sea posible, evitar dependencias externas. Todavía no tenemos, por ejemplo, soporte para videos H.264 por el simple hecho de que esto requiere componentes externos, aunque sean gratuitos. Queremos una implementación limpia, 100 % Rust.

El widget de acceso a base de datos soporta SQLite, PostgreSQL y MySQL a través de bibliotecas Rust.

Sobre el sistema de archivos indexados de RustCOBOL (ISAM)

1. Arquitectura

Un único trait IndexedStore (crates/cobolt-runtime/src/indexed.rs) define la interfaz que utiliza el intérprete. Hay dos backends detrás de un Box<dyn IndexedStore>:

Backend|STORAGE IS|Archivo|Característica[/TH][/TR]
IndexedFile (memoria)|MEMORY|indexed.rs|todo en RAM; se guarda en CLOSE
DiskIndexedFile (disco)|DISK (por defecto)|indexed_disk.rs|archivo paginado persistente, leído bajo demanda


Sin dependencias externas — motor ISAM propio.

“Sabor” de engine:

--indexed-engine {rust|rm-cobol85|fujitsu}

o:

COBOL_INDEXED_ENGINE

Actualmente, rm y fujitsu delegan al engine Rust.

Los verbos de archivo son despachados por la ORGANIZATION del SELECT.

2. Engine de memoria (indexed.rs)

records: BTreeMap<clave-primaria, registro> // KSDS ordenado
alt_index: Vec<BTreeMap<clave-alt, BTreeSet<RecordId>>>
locks: HashMap<clave, LockMode{Shared|Exclusive}>
journal: Vec<Journal{Insert|Update|Delete}> // undo para ROLLBACK

BTreeMap proporciona ordenación natural para START, READ NEXT y READ PREVIOUS.

3. Engine de disco (indexed_disk.rs) — formato PRCIDXD1

Páginas fijas de 4 KiB, con free-list. Las páginas liberadas son reutilizadas. Los punteros y contadores son u64.

B+tree por clave — primaria + alternativas: hojas/internas byte-packed, split en la inserción y hojas doblemente encadenadas para barrido ordenado.

Directorio de RecordId: RecordId estable → ubicación física. Un REWRITE que mueve el registro actualiza solo el directorio.

Slotted data pages: varios registros por página + cadena de overflow para registros mayores que una página.

WITH COMPRESSION: RLE estilo PackBits (compress.rs), rápido, y nunca crece más de 1 byte.

Undo log en ejecución — nuevo en v1.8.0: soporta ROLLBACK real. Antes era no-op.

4. Transacciones COMMIT / ROLLBACK (v1.8.0)

Semántica — se aplican a todos los archivos INDEXED abiertos:

Verbo|Efecto[/TH][/TR]
OPEN|inicia una transacción
COMMIT|hace durable todo desde el último COMMIT/OPEN e inicia una nueva transacción
ROLLBACK|deshace todo WRITE/REWRITE/DELETE desde el último COMMIT/OPEN
CLOSE|persiste los cambios mediante commit implícito


Implementación: el engine acumula un undo log con operaciones inversas:


Insert → delete
Update → reescribe la imagen anterior
Delete → regraba la imagen anterior


ROLLBACK reaplica los inversos en orden reverso, con guard tx_replay para no registrar nuevamente en el log, y vuelve a persistir.

COMMIT descarta el log y ejecuta sync_all.

COMMIT y ROLLBACK son tokens reservados. No son absorbidos por un DISPLAY anterior.

Atención: es rollback a nivel de programa, dentro de la ejecución. La recuperación post-crash mediante WAL durable sigue siendo trabajo futuro.

5. Recursos implementados

Claves: RECORD KEY única + N ALTERNATE RECORD KEY [WITH DUPLICATES].

Modos de acceso:

ACCESS MODE SEQUENTIAL
ACCESS MODE RANDOM
ACCESS MODE DYNAMIC

Verbos:

OPEN {INPUT|OUTPUT|I-O|EXTEND} [SHARING WITH …][WITH LOCK]
CLOSE
WRITE (INVALID KEY)
REWRITE
DELETE
READ (random / NEXT/PREVIOUS / KEY IS altkey / WITH [NO] LOCK)
START KEY IS {= > >= < <=}
UNLOCK
COMMIT
ROLLBACK

FILE STATUS de 2 dígitos:

00, 02, 10, 22, 23, 24, 35, 46, 47/48/49, 99, …

Bloqueo de registros, modelo KSDS, más journal/undo, persistencia, compresión opcional y selección de almacenamiento/engine.

6. Ejemplos de uso — ejecutados ahora

(1) CRUD con clave primaria + alternativa, DISK WITH COMPRESSION

Flujo:

OPEN OUTPUT/I-O
WRITE
READ random
INVALID KEY
REWRITE
START GREATER + READ NEXT
READ KEY IS (alternativa, duplicados)
DELETE

Salida:

RANDOM 0002: BRUNO
0099 INVALID KEY, ST=23
REWRITE ST=00
SEQ 0001 ANA
SEQ 0002 BRUNINHO ← REWRITE aplicado; orden por clave primaria
SEQ 0003 CARLOS
ALT SP #1: CARLOS ← lectura por clave alternativa CIDADE="SP"
ALT SP #2: BRUNINHO ← READ NEXT en el duplicado
DELETE 0001 ST=00
0001 apagado, ST=23
FIM

(2) Persistencia entre ejecuciones

Otro proceso solo lee el archivo /tmp/clientes.idx de la ejecución anterior:

Reabierto (otra ejecución). Registros persistidos:
0002 BRUNINHO SP
0003 CARLOS SP ← 0001 ANA sigue apagado; REWRITE/DELETE sobrevivieron

(3) Transacción COMMIT/ROLLBACK

Graba GAMMA, hace COMMIT. Después graba DELTA, altera ALPHA, borra BETA y hace ROLLBACK:

OPEN I-O F
MOVE 0003 ... WRITE R-REC *> GAMMA
COMMIT
MOVE 0004 ... WRITE R-REC *> DELTA
MOVE 0001 ... READ F MOVE "ALPHAX" ... REWRITE R-REC
MOVE 0002 ... DELETE F
ROLLBACK

Salida idéntica en los engines de disco y memoria:

Después del ROLLBACK, barrido:
0001 ALPHA ← REWRITE deshecho
0002 BETA ← DELETE deshecho
0003 GAMMA ← COMMIT anterior sobrevive
← 0004 DELTA removido (WRITE deshecho)

7. Cobertura de pruebas — verde ahora

Suite (Rust)|Resultado
test_transactions (COMMIT/ROLLBACK — disco y memoria)|2 passed
test_indexed (engine ISAM)|2 passed
test_file_locking (OPEN SHARING/LOCK, READ WITH [NO] LOCK, UNLOCK, CANCEL)|4 passed
test_fileio_storage (6 variantes: baseline + memory/disk × compression)|7 passed




El acceso SQL previsto es nativo o mediante ODBC? (Drivers nativos de Rust para SQLite, MySQL y PostgreSQL)

Gracias, buen trabajo,
José

Por falta de créditos, no tendremos avances hasta el próximo miércoles.

Conviértete en sponsor para descargar el código, seguir de cerca el progreso y contribuir con las pruebas.

¡Saludos!

[Joseg]

OK, Ja sei que tambem falam em Portugues!!

Nao estou a conseguir fazer doaçao. Esta operacional?!
GitHub - CloudLandBeta/PowerRustCOBOL-funding: Public repository for gaining access to the private PowerRustCOBOL repository containing the source code by becoming a sponsor. · GitHub (https://github.com/CloudLandBeta/PowerRustCOBOL-funding)

Boa continuaçao.


El archivo indexado de RustCOBOL no es compatible con Fujitsu en términos de estructura de archivo, pero implementa el 99 % de la especificación COBOL-85 utilizada por Fujitsu COBOL85, lo que facilita la conversión de datos de un formato a otro prácticamente sin impactos en el código.

RustCOBOL y TODOS sus componentes son OPEN-SOURCE y GRATUITOS. Nada de licencias pagas, aunque en el futuro podamos ofrecer soporte pago. Nuevamente: el compilador, el RAD y las herramientas son 100 % gratuitos. ¡100 %!
...

[Eslopes]

Grato por sua resposta. Estou aguardando a aprovação do GitHub dos dados fiscais que fui obrigado a fornecer. Deve ser liberado em breve. Colocarei um aviso no fórum.

Aquí está el esquema conceptual del motor de índice en disco implementado (DiskIndexedFile, contenedor PRCIDXD1).
Este es el formato persistente; el motor en memoria es un subconjunto simplificado del mismo modelo.

1. El archivo = un array de páginas fijas de 4 KiB

byte 0 end of file
┌────────┬────────┬────────┬────────┬────────┬──── ────┬───── ... ─────┐
│ Page 0 │ Page 1 │ Page 2 │ Page 3 │ Page 4 │ Page 5 │ ... │
│ HEADER │ B+tree │ B+tree │ DATA │ DATA │ DIR │ │
└────────┴────────┴────────┴────────┴────────┴──── ────┴───────────────┘
Cada página tiene exactamente PAGE_SIZE = 4096 bytes;
page id = desplazamiento en bytes / 4096

Cada página después de la página 0 se identifica por su primer byte (etiqueta de tipo):

| Tag | Page type | Contenido |
|-----|-------------|------------------------------------------------|
| 1 | PT_INTERNAL | Nodo interno de B+tree |
| 2 | PT_LEAF | Nodo hoja de B+tree (doubly linked) |
| 3 | PT_DATA | Página con slots que contiene varios registros |
| 4 | PT_OVERFLOW | Continuación para registros demasiado grandes |
| 5 | PT_DIR | Un fragmento del directorio de RecordId |

Las páginas pueden liberarse y reutilizarse mediante una free list, por lo que el orden físico en disco no corresponde al orden lógico.

2. Página 0 — el encabezado (se escribe una sola vez, es el único esquema del archivo)

PRCIDXD1 version page_size rec_fmt compressing record_len
(8 bytes) (u16) (u32) (u8=1) (u8 0/1) (u32)
────────────────────────────────────────────────── ────────────
next_page_id free_list_head record_count data_tail (cada u64)
primary_root dir_head directory_len (cada u64)
────────────────────────────────────────────────── ────────────
alt_root_count (u16) → [ alt_root : u64 ] × N (una raíz B+tree por clave alternativa)
────────────────────────────────────────────────── ────────────
KEY SCHEMA: key_count (u16) → para cada clave:
duplicates_allowed (u8)
part_count (u16) → [ offset:u32, length:u32 ] × partes (claves compuestas)

Nota: No hay nombres de campos ni metadatos por registro. El esquema solo define la geometría de las claves (rangos de bytes).

3. Ruta de acceso (cómo se resuelve un READ)

COBOL key value (bytes)
│
▼
┌──────────────┐ primary_root / alt_roots[k]
│ B+tree (uno │ por clave. Las páginas internas enrutan;
│ por clave) │ las hojas contienen (key_bytes → RecordId)
└──────┬───────┘ y están doubly linked para READ NEXT / PREVIOUS.
│ RecordId (un entero estable)
▼
┌──────────────┐ directory[RecordId] = RecLoc
│ Directorio │ { kind, page, slot, len }
│ de RecordId │ kind: 0=free/tombstone 1=inline 2=overflow
└──────┬───────┘
│ (page, slot)
▼
┌──────────────┐ slotted DATA page → slot dir → (offset,len)
│ DATA page │ → imagen raw del registro (opcionalmente comprimida)
└──────┬───────┘
▼
los bytes del registro de ancho fijo → RecordLayout.distribute()
los distribuye en los subcampos del FD en memoria.

Todos los índices (primario + alternos) apuntan al mismo RecordId, por lo que existe exactamente una copia de cada registro.

4. Una página PT_DATA vista en detalle

┌─ byte 0 ─┬─ 1..3 ─┬─ 3..5 ──┬─ slot directory ─────┬─ ... free ... ─┬─ record data ─┐
│ type=3 │ slot_ │ free_ │ (off:u16,len:u16) ×N │ │ packed │
│ │ count │ top │ grows → │ │ ← grows │
└──────────┴────────┴─────────┴─────────────────── ───┴───────────────┴───────────────┘

El directorio de slots crece desde el frente, los registros desde el final. Los registros más grandes que una página se desbordan en una cadena PT_OVERFLOW.

5. Imagen del registro (posicional, sin nombres)
Ejemplo: 01 CUST. 05 ID PIC 9(5). 05 NAME PIC X(10). 05 CITY PIC X(8).:

offset: 0 5 15 23
┌────────┬────────────────────┬────────────── ─┐
payload: │ 00001 │ John Doe │ Sao Paulo │ ← 23 bytes, fixed
└────────┴────────────────────┴────────────── ─┘
ID(5) NAME(10) CITY(8)

materialize() empaqueta los subcampos en este buffer; distribute() hace lo inverso. Con compresión, se aplica PackBits-RLE.

6. Estructuras transversales

* Free list — free_list_head encadena las páginas liberadas para reutilizar espacio.
* Directorio de RecordId — reside en RAM mientras el archivo está abierto, se persiste en páginas PT_DIR.
* Transacciones — undo log en RAM (inversas de Insert/Update/Delete). ROLLBACK las aplica; COMMIT las descarta y hace flush.
* Validación estricta en OPEN — compara el esquema de claves almacenado con el del programa; mismatch → file status 39.

En una oración: un archivo paginado compuesto por un header + N B+trees (uno por clave) → directorio de RecordId → páginas de datos con slots de registros de ancho fijo posicionales, con free list, cadenas de overflow, compresión RLE opcional y undo log para transacciones.

[Eslopes]

Estimados,

Les comparto el enlace a la página de financiación. Para contribuir, hagan clic en el botón “Sponsor”.

Al realizar una donación mensual, tendrán acceso al repositorio privado con el código fuente:

GitHub - CloudLandBeta/PowerRustCOBOL-funding: Public repository for gaining access to the private PowerRustCOBOL repository containing the source code by becoming a sponsor. · GitHub (https://github.com/CloudLandBeta/PowerRustCOBOL-funding)

Conviértanse en patrocinadores hoy mismo y ayuden a construir la nueva generación de entornos gráficos para COBOL, con soporte para Generative AI, REST APIs, servicios en la nube, integración con Rust y mucho más.

Con su apoyo, será posible acelerar el desarrollo, mejorar la estabilidad, crear ejemplos, ampliar la documentación y transformar PowerRustCOBOL en una plataforma moderna, abierta y útil para la comunidad COBOL.

¡Saludos!

[Eslopes]

Ahora la IDE cuenta con una mejor estructura para los proyectos. La buena y vieja conocida vista en árbol de proyectos está de vuelta, así como la capacidad de modificar rápidamente las propiedades de los objetos de un formulario sin abrir el RAD.

¡Saludos!

[luisbago]

Estimados,

Les comparto el enlace a la página de financiación. Para contribuir, hagan clic en el botón “Sponsor”.

Al realizar una donación mensual, tendrán acceso al repositorio privado con el código fuente:

GitHub - CloudLandBeta/PowerRustCOBOL-funding: Public repository for gaining access to the private PowerRustCOBOL repository containing the source code by becoming a sponsor. · GitHub (https://github.com/CloudLandBeta/PowerRustCOBOL-funding)

Conviértanse en patrocinadores hoy mismo y ayuden a construir la nueva generación de entornos gráficos para COBOL, con soporte para Generative AI, REST APIs, servicios en la nube, integración con Rust y mucho más.

Con su apoyo, será posible acelerar el desarrollo, mejorar la estabilidad, crear ejemplos, ampliar la documentación y transformar PowerRustCOBOL en una plataforma moderna, abierta y útil para la comunidad COBOL.

¡Saludos!

creo que me sacaron:
You were removed from the CloudLandBeta organization because you don’t meet its two-factor authentication requirements. Review your two-factor authentication settings.

[Eslopes]

Si, es necesario habilitar autenticación usando um dispositivo que gere um token (pode ser o app do google authenticator no celular ou o app do próprio GitHub)
creo que me sacaron:
You were removed from the CloudLandBeta organization because you don’t meet its two-factor authentication requirements. Review your two-factor authentication settings.

Post añadido a las 22:21. Post anterior a las 20:42

Muchas personas están dispuestas a financiar el proyecto, pero GitHub tarda algunas semanas en aprobar la documentación requerida.

Voy a poner el repositorio del código de PowerRustCOBOL como público, de modo que, por ahora, cualquiera podrá descargar el código fuente sin donar nada. El código aún no está completamente funcional, excepto por el compilador. Muchos widgets todavía tienen propiedades o métodos que no funcionan. Estoy corrigiéndolos uno por uno, pero llevará algún tiempo. Por eso, no tiene sentido exigir en este momento donadores regulares para algo que TODAVÍA no tiene mucha utilidad práctica.

Al liberar el código para descarga, todos podrán contribuir con sugerencias. Recordando que la solución en sí es gratuita y seguirá siéndolo debido a la licencia Apache 2.0.

Aunque el compilador, el entorno de desarrollo gráfico y el runtime sean gratuitos y open-source, la integración con la nube y con modelos de Generative AI para generación de código o análisis de datos podrán tener costos. Aun así, nada impedirá que alguien cree su propia infraestructura en la nube para complementar la IDE.

Repito: la IDE, el compilador y el runtime no dependen de servicios actuales ni futuros para ejecutarse. Sin embargo, ciertas funciones que consumen servicios externos, ya sea en Google Cloud o en AWS, podrán generar costos por el uso de dichos servicios. El propio Anthropic Claude Code, usado intensamente en el desarrollo de PowerRustCOBOL, es pago y tiene un costo elevado.

Ya existe una Guía del Desarrollador de PowerRustCOBOL. Todavía necesita algunas imágenes y el contenido aún está en proceso de redacción, pero ya permite tener una idea clara de lo que es el proyecto.


Accede aquí al repositorio público de PowerRustCOBOL: GitHub - CloudLandBeta/PowerRustCOBOL: Modern IDE for development of COBOL applications connected to the Cloud, Agentic AI, and rich UI. 100% Free · GitHub (https://github.com/CloudLandBeta/PowerRustCOBOL)

Post añadido a las 23:08. Post anterior a las 22:21

Una cosa que siempre me incomodó en PowerCOBOL 3, y que ahora pude —y de hecho corregí—, fue el soporte a inferencia de tipos. Siguen algunos ejemplos:

PowerCOBOL:
working-storage section.
77 data-item pic x(60) value spaces.

move "Caption" of Label1 to data-item
display data-item

PowerRustCOBOL:

display "Caption" of Label-1

Simple, directo, sin necesidad de declarar ítems en la Working-Storage. Funciona para todos los verbos de COBOL.

compute salary = "Value" of Textbox-1 + "Value" of Textbox-2
IF ("Value" of Textbox-1 = 1 or 2 or 3 or > 10)
string "Caption" of Label-1
"Value" of Textbox-3
into "Value" of Textbox-4
END-IF

[Eslopes]

Una versión en español del Developer’s Guide (Guía del Desarrollador) está disponible en el GitHub de PowerRustCOBOL.

[Kuk]

Una cosa que siempre me incomodó en PowerCOBOL
A mi también siempre me pareció muy incomodo e incluso, diría yo, una chapuza. Porque llegados al punto de manejar controles visuales por Cobol, ya podían haberse esfozrado un poco más y hacerlo como lo has hecho tú, que tiene toda la lógica del mundo! :bien:

Post añadido a las 20:55. Post anterior a las 20:33

P.D. creo que @Nitzer va a fliapr cuando vea la que se está montando :D :D :D

[Eslopes]

IDE casi terminada; el RAD, no tanto.

Cada día, una imagen diferente. Cada 6 segundos, una cita para inspirar tu día.

[luisbago]

tal vez es una obviedad pero... se puede publicar o mostrar como ejemplo el github público de PowerRustcobol y esta hilo en otros lugares sobre LLM y claude code?

[Eslopes]

Este foro es público, lo que significa que el contenido que publicamos aquí puede compartirse o utilizarse sin necesidad de permiso previo. El único detalle que llama la atención aquí es que el repositorio de PowerRustCOBOL pasará a ser privado tan pronto como GitHub apruebe la documentación que permite aceptar patrocinadores. Apuntar a un repositorio que eventualmente será puesto como privado —y que después volverá a ser público solo dentro de algunos meses— dará como resultado un error 404, dando la impresión de que el proyecto murió para quien intente acceder a tu enlace. En fin, no tengo objeciones si quieres publicar este hilo en otros lugares, pero quería dejar esta observación.


tal vez es una obviedad pero... se puede publicar o mostrar como ejemplo el github público de PowerRustcobol y esta hilo en otros lugares sobre LLM y claude code?

[Eslopes]

Hola,

Vamos a necesitar un nuevo foro: PowerRustWebCOBOL.

Además de ofrecer el soporte tradicional para macOS, Linux y Windows, PowerRustCOBOL recibirá un módulo para desarrollar aplicaciones gráficas para el navegador web usando WebAssembly.

La idea es mantener el mismo look and feel, el mismo modelo visual y de eventos, y los mismos recursos del entorno desktop —con algunos recursos adicionales—, pero permitiendo que la aplicación se ejecute en el navegador de forma nativa mientras accede a datos de manera remota.

Pronto publicaremos un ejemplo.

Hasta donde sé, ningún otro compilador COBOL ofrece una experiencia RAD moderna, inspirada en PowerCOBOL, capaz de generar aplicaciones gráficas para el navegador usando WebAssembly y manteniendo el mismo modelo visual y de eventos del entorno desktop.

Más información: https://www.youtube.com/watch?v=cbB3QEwWMlA

[Paulo]

Existe algo que devo estar a fazer mal, mas não consigo fazer a doação.
Podem ajudar ?

[Joseg]

Existe algo que devo estar a fazer mal, mas não consigo fazer a doação.
Podem ajudar ?

Também já tentei, mas penso que ainda não esta ativo essa possibilidade.

José.

[Eslopes]

Não depende de mim. O Github ainda não aprovou o sponsorship, apesar de ter passado todas as informações que solicitaram.
acho que vou usar o gofundme para isto....


Também já tentei, mas penso que ainda não esta ativo essa possibilidade.

José.