Reviews run for a minimum of one week. The outcome of the review is decided on this date. This is the last day to make comments or ask questions about this review.
Eclipse Intelligent Developer Agent
The project originated from my experience as a software engineer working across diverse environments, ranging from academic systems to enterprise-grade platforms, where I repeatedly encountered the challenges of architectural complexity, fragile integration layers, and the lack of secure, accessible development tools, especially in under-resourced regions.
I began designing what would later become the TModeler/TSM/THC suite with the idea of building an intelligent and secure developer agent that could automate data modeling, synchronize distributed instances, and enforce security principles directly at the core of software architecture.
Over time, this prototype evolved into a general vision: to lower the mental and technical burden on developers by offering a set of declarative, interoperable tools that encourage better design practices and reduce reliance on cloud-centric, vendor-locked systems.
The need for local-first, decentralized, and cryptographically secure developer infrastructure, especially in contexts where internet connectivity or proprietary tooling is unreliable, reinforced the motivation to make this project fully open and community-driven.
The Eclipse Intelligent Developer Agent project is an open-source suite designed to simplify and secure the development of distributed, model-driven systems through three components: TModeler, TSM, and THC.
TModeler is a cross-platform, multi-language ORM and modeling engine that adheres strictly to object-oriented principles. Models, relationships, and filters are defined using pure language constructs, no annotations, no external syntax, resulting in intuitive, high-fidelity data modeling. It supports a wide variety of field types, from basic (IntField, SecureTextField) to advanced (GeoField, ModelField, FileField, JsonField, ListField), enabling expressive, type-safe model definitions across domains.
TSM provides seamless, real-time synchronization between distributed model instances without requiring manual APIs or data bindings.
THC embeds a cryptographic layer into the modeling engine, offering field-level encryption, digital signatures, and secure identity management.
The project is especially valuable for developers working in under-resourced or decentralized environments who seek robust, transparent, and vendor-neutral tools.
The Eclipse Intelligent Developer Agent project delivers an open-source suite of three interoperable components designed to support secure, decentralized, and model-driven software development:
- TModeler : a multi-language modeling and ORM engine that allows developers to define, validate, and bind complex data structures across platforms (C++, Java, Python), including spatial and secure fields.
- TSM : a synchronization engine that ensures real-time consistency between client and server model instances, eliminating the need for manually written APIs or bindings.
- THC : a cryptographic layer integrated at the model level, offering encryption, digital signatures, and identity management directly within the development workflow.
In-scope :
- Declarative model-driven development tools
- Automatic synchronization and code binding between frontend and backend
- Field-level cryptographic protection (encryption, signatures)
- Cross-platform compatibility (C++, Java, Python)
- Developer empowerment in under-resourced environments
Out-of-scope :
- Development of a full IDE or general-purpose cloud platform
- Standardization of formal APIs beyond this project’s context
- Proprietary deployment models or integration with closed-source ecosystems
The project complements existing development tools by automating and securing core architectural layers, without seeking to replace them.
There are no known legal issues associated with this project.
All code has been developed from scratch by the project maintainer and is free from third-party components under incompatible or problematic licenses. The entire codebase will be licensed under the Apache License 2.0, with the GNU General Public License v3 as a secondary license to preserve compatibility with copyleft environments. Documentation will be published under the Creative Commons Attribution-ShareAlike 4.0 license.
The project names “TModeler”, “TSM”, and “THC” are original and currently not registered as trademarks. They have been used exclusively within this project since early 2024. There are no known conflicts or claims from other entities. Should formal trademark registration be pursued in the future, it will be done transparently and in alignment with the Eclipse Foundation’s trademark guidelines.
The Intelligent Developer Agent project brings a unique combination of model-driven architecture, real-time synchronization, and embedded cryptography to the Eclipse ecosystem. Its core focus empowering developers through declarative, secure, and offline-friendly tooling, aligns well with Eclipse’s mission to support open and extensible development platforms.
By hosting this project within Eclipse, we hope to contribute:
- A lightweight, language-agnostic modeling engine (TModeler) that complements existing frameworks like EMF
- An open alternative to proprietary real-time sync and integration tools (TSM)
- A developer-centric cryptographic layer built for trust-by-design applications (THC)
In return, we seek the Eclipse Foundation’s support to:
- Reach a broader community of developers, especially in modeling and embedded systems
- Benefit from a well-established governance model and infrastructure
- Collaborate with projects under the Eclipse Modeling and Eclipse Technology umbrellas
- Establish long-term credibility through transparent, community-driven development
We believe Eclipse offers the ideal environment to grow a project that combines software freedom, developer empowerment, and architectural rigor.
In the next 12 to 18 months, the project will follow the roadmap outlined in its current development plan:
🔹 June-August 2025: Core engine expansion
- Complete the integration of 'GeoField' into TModeler, including spatial filters and query extensions
- Finalize 'TVirtualModel' support for cross-model filtering and dynamic relationships
- Implement 'TSpace', a variable-dimension modeling layer for flexible data topologies (grids, 3D logic, simulation)
- Ensure consistent implementation across C++, Java, and Python bindings
🔹 September-November 2025: Platform team foundation
- Launch parallel development of TModeler, TSM, and THC across supported languages
- Create specialized frontend integration teams (Qt for C++, Jetpack Compose for Android/Java)
- Refactor frontend bridges to enable reusable component architectures
- Improve documentation and onboarding materials
🔹 December 2025: Full integration testing
- Conduct large-scale integration testing across all platforms
- Simulate complex, real-world applications to validate performance and scaling
- Refine synchronization and security performance benchmarks
🔹 2026: Educational rollout and interaction layers
- Launch pilot use in training centers and academic institutions
- Develop education programs focused on secure, model-based development
- Begin research and design on a DSL or NLP interface for declarative interaction
- Explore IDE and low-code integrations
On the community side, planned activities include:
- Launching a public community portal
- Publishing demo apps, use cases, and tutorials
- Hosting online workshops and meetups
- Partnering with open education programs
- Seeking research collaboration in modeling, distributed systems, and cryptography
The project is currently finalizing the full source code for public release across its three components: TModeler, TSM, and THC. Experimental versions and architectural previews are already available on GitHub.
We expect to publish the initial full codebase, with proper licensing and documentation, in the second half of 2025. The first stable, cross-platform builds (C++, Java, Python) are planned following integration and testing between late 2025 and early 2026.
A unified documentation and demonstration portal is also under development and will accompany the release to support onboarding and community adoption.
Development is currently led by the original author, with the intent to open the project to contributors and establish a governance model during 2025. Educational deployment and training programs are targeted for early 2026.
The following individuals and communities have expressed interest in the project, either through technical discussions, demonstrations, or early feedback:
- Independent developers and open-source contributors in Cameroon and francophone Africa
- Academic contacts and researchers in software modeling and distributed systems in France and Canada
- Professionals in GIS, education technology, and privacy-focused systems who have reviewed early demos
- Ongoing informal discussions with individuals affiliated with:
- MIT Media Lab
- Astek France
- Linux Foundation (exploratory contact)
- Software Freedom Conservancy (formal application submitted)
Although no formal partnerships are established yet, this early interest demonstrates the project’s relevance across domains such as secure modeling, education, and decentralized system design.
The initial contribution will consist of three interconnected libraries: TModeler, TSM, and THC. These components have been developed and maintained by a single author, FOTSING TAMBO Luc Olivier, who holds full copyright ownership of the codebase.
Each component serves a distinct role within the system:
- TModeler is a multi-language ORM and modeling engine (C++, Java, Python) supporting declarative model definitions, UI binding adapters (e.g., TViewModel<TModel>), and advanced field types including GeoField, ModelField, ListField, and SecureField.
- TSM is a real-time synchronization engine that transparently syncs model data between clients and servers without requiring manual APIs or bindings.
- THC embeds hybrid cryptography at the model layer, providing field-level encryption, digital signatures, and secure identity management.
The code is currently hosted in three public GitHub repositories ([TModeler](https://github.com/TTT-GH/TModeler), [TSM](https://github.com/TTT-GH/TSM), [THC](https://github.com/TTT-GH/THC)) which contain architecture previews, demos, and early builds. The full source code for each component, along with documentation and licensing, is being finalized for release under the Apache 2.0 as primary.
No third-party libraries under incompatible licenses are included in the codebase. All dependencies used for testing and UI integration (e.g., Qt, Jetpack Compose) are under permissive or GPL-compatible licenses.
The initial community is still emerging, with interest from academic and professional developers in Africa, Europe, and Canada. The project is in the process of building a governance model to welcome external contributors.
- Log in to post comments
The Eclipse Intelligent Developer Agent project delivers an open-source suite of three interoperable components designed to support secure, decentralized, and model-driven software development:
- TModeler : a multi-language modeling and ORM engine that allows developers to define, validate, and bind complex data structures across platforms (C++, Java, Python), including spatial and secure fields.
- TSM : a synchronization engine that ensures real-time consistency between client and server model instances, eliminating the need for manually written APIs or bindings.
- THC : a cryptographic layer integrated at the model level, offering encryption, digital signatures, and identity management directly within the development workflow.
In-scope :
- Declarative model-driven development tools
- Automatic synchronization and code binding between frontend and backend
- Field-level cryptographic protection (encryption, signatures)
- Cross-platform compatibility (C++, Java, Python)
- Developer empowerment in under-resourced environments
Out-of-scope :
- Development of a full IDE or general-purpose cloud platform
- Standardization of formal APIs beyond this project’s context
- Proprietary deployment models or integration with closed-source ecosystems
The project complements existing development tools by automating and securing core architectural layers, without seeking to replace them.
- Log in to post comments
This project was born from…
Submitted by Luc Olivier FO… on Tue, 06/10/2025 - 03:49
This project was born from two core motivations:
1. To reduce the mental and technical burden placed on software developers by
providing them with a structured, intelligent tool that promotes quality,
productivity, and mental well-being. After years in the field, I saw how
managing data complexity in real-world systems can become overwhelming and
even exhausting. This agent aims to automate repetitive, stressful patterns
and restore clarity to system design.
2. To make software engineering more accessible and less intimidating,
especially in regions with limited access to advanced tools. By abstracting
complexity and encouraging creative thinking, I hope to help new generations
understand that programming is not reserved for the elite, but is a field
where innovation and imagination can thrive.
In short: this project is an effort to both humanize and democratize software
engineering.
---
Thank you for your time and for considering this application.
I would be honored to contribute to your mission and to
collaborate with its vibrant community. I remain fully available to provide
any additional material, technical documentation, or a live presentation of
the project if helpful.
Sincerely,
FOTSING TAMBO Luc Olivier
📧 olivierdhon@gmail.com
📞whatsapp +237 653 379 379
🔗 https://github.com/TTT-GH