Core Engine

KB Sync

Name: KB Sync
Brand: KBbridge
Price: 200.00 USD
Availability: InStock

The intelligent bridge between your GeneXus Knowledge Base and modern development.

Automatic bidirectional synchronization, specify and compile on request, AI support, and full control from a visual interface.

Download now View pricing View KB Editor

The challenge

Why do you need KB Sync?

GeneXus teams face a frustrating reality: their code lives locked inside a proprietary Knowledge Base, inaccessible to the modern tools that are transforming software development.

Trapped code

Your business logic lives inside the GeneXus KB. You can't version it with Git, review it as a team, or use AI tools to improve it.

No real Git

GeneXus doesn't work with text files. No files means no Git. No Git means no pull requests, no code review, no reliable change history.

Blind AI

Claude, Copilot, Cursor — all AI tools need text files to work. The binary GeneXus KB leaves them completely out.

Isolated teams

Each developer works on their own island. There's no simple way to see what changed, who changed it, or when.

Compiling means going back to the IDE

Even if you edit outside, you have to open the IDE and wait in order to specify, generate or compile. That round trip breaks your flow.

Fear of change

You want to modernize but can't abandon your GeneXus investment. You need a bridge, not a break.

KB Sync solves all of this. It externalizes your Knowledge Base to plain text files — versionable, editable, and AI-ready — and specifies, generates and compiles on request, all without leaving GeneXus behind.

How it works

Intelligent synchronization

KB Sync transforms your Knowledge Base objects into plain text files and keeps them synchronized in both directions. Edit with KB Editor, AI, or any tool — and changes flow back to GeneXus automatically, with specification and compilation on request.

Connect your KB

Point KB Sync at your GeneXus Knowledge Base and at the directory where you want the files.

Automatic export

KB Sync detects new, modified, renamed or moved objects and turns them into plain text files in real time.

III

Edit freely

Use KB Editor with IntelliSense, visual editors and AI, or any tool you prefer. The files are pure text.

Sync and build back

On save, changes are validated and imported into the Knowledge Base in dependency order — and you can request specification, generation or compilation without opening the IDE.

Components

Everything you need, in one package

KB Sync is made of two applications that work together: a visual control panel and a synchronization engine.

Control Panel

KB Sync Manager

The visual application where you control everything. Configure your Knowledge Bases, manage synchronization, decide how and when to build, and monitor activity — all from the Windows system tray.

✦Multiple KBs with real-time status indicators
✦Live console with two channels: General (synchronization) and Build
✦Search inside the console and the log viewer (Ctrl+F) with a match counter
✦Filters by module, folder or object type
✦Per-KB build settings: automatic build after sync, scope and environment
✦Detection of the KB's environments so you can pick which one to build against
✦Automatic deployment of documentation for AI tools
✦Automatic start with Windows and per KB
✦Windows Server support with independent sessions

Synchronization Engine

KB Sync Engine

The engine that does the heavy lifting. Continuous bidirectional sync cycles that keep your files and your KB perfectly aligned, plus a build queue that runs alongside them.

✦Incremental export: only processes what changed since the last cycle
✦Import in dependency order, with automatic retries within the same cycle
✦Support for 20+ GeneXus object types, including Forms, report layouts and File objects
✦Specification, generation and compilation on request, with a navigation report per object
✦Configurable cycles (default: every 10 seconds)
✦Compatible with GeneXus X, X Evo1, X Evo2, X Evo3, 15, 16, 17 and 18

Built-in build

Specify, generate and compile without opening the IDE

KB Sync doesn't just move files: it runs the full GeneXus cycle on request. From KB Editor you ask to specify, generate or compile, and the engine returns each object's errors and navigation report.

Four scopes

Specify (fast: navigation plus semantic errors), Specify + Generate, Build with compilation, and Build Called to include the whole tree of called objects.

Never interrupts the sync

Requests are queued and run one at a time in a separate process: a long compilation never delays the import/export cycle. If the engine restarts, pending requests are picked up again.

Errors on the exact object

Every message comes back attributed to the object that produced it, with code, section, line and column when available, and the phase it came from: specification, generation or compilation.

Navigation report

Each built object returns its Navigation Report as a self-contained HTML file with the IDE's own look, plus a consolidated navigation set per object and environment.

Automatic build after sync

Optional: after each cycle that internalizes objects, the engine waits a configurable quiet window and builds everything it accumulated as a single batch, attributed to the user who triggered it.

Environments

The engine publishes the KB's environments and you pick which one to build against — or you lock one from the Manager. The switch is per user: it never changes the environment of whoever is working in the IDE.

Pattern instances

If the request includes a Pattern Instance, the engine applies the pattern first (the IDE's Apply Pattern) and then builds the generated objects and their parent object.

Build All

Specification of the whole Knowledge Base on request, reporting only the objects GeneXus actually re-specified. Useful after broad-impact changes, such as a Domain's enumerated values.

The engine never triggers a database reorganization as part of a build. Available on GeneXus X Evo1, X Evo2, X Evo3, 15, 16, 17 and 18.

AI Ready

Ready for any AI tool

KB Sync Manager automatically deploys context documentation so AI tools understand your GeneXus project from the very first prompt.

AI Tool	Deployed file
Claude Code	ai/CLAUDE.md
Codex	ai/CODEX.md
GitHub Copilot	.github/copilot-instructions.md
Cursor	.cursorrules
Windsurf	.windsurfrules
Cline	.clinerules
Roo Code	.roorules

It also deploys ai/start-here.md as a general entry point and a full ai/kbbridge/ folder with reference documentation for the GeneXus language, file formats, diagnostic guides for import errors, and a per-object-type property catalog (allowed values, defaults and applicable version).

Compatibility

20+ supported object types

KB Sync works with virtually every GeneXus object type. Each object becomes one or more readable, editable plain text files — and only the properties that differ from their default are written out.

Object Type	Extension	Read	Write
Procedure	.Procedure.gxSource + .gxLayout	Yes	Yes
Transaction	.Transaction.gxSource + .gxForm	Yes	Yes
Web Panel	.WebPanel.gxSource + .gxForm	Yes	Yes
Web Component	.WebComponent.gxSource + .gxForm	Yes	Yes
Web Master Page	.WebMasterPage.gxSource + .gxForm	Yes	Yes
Panel (Smart Device)	.Panel.gxSource + .gxForm	Yes	Yes
Work Panel	.WorkPanel.gxSource	Yes	Yes
Data Provider	.DataProvider.gxSource	Yes	Yes
Data Selector	.DataSelector.gxSource	Yes	Yes
SDT	.StructuredDataType.gxSource	Yes	Yes
External Object	.ExternalObject.gxSource	Yes	Yes
API	.API.gxSource	Yes	Yes
Group / Subtype Group	.Group.gxSource	Yes	Yes
Unit Test	.UnitTest.gxSource	Yes	Yes
File (attachments)	.File.gxSource + .File.gxFile	Yes	Yes
Domain	.gxDomain	Yes	Yes
Attribute	.gxAttribute	Yes	Yes
Table	.Table.gxSource	Yes	User-defined indexes only
Pattern Instance	.gxPattern	Yes	Yes
User Controls	User Controls/	Yes	—
Pattern definitions	Patterns/	Yes	—

Tables are exported as a reference AI tools can consult; their user-defined indexes are editable from the plain text file. User Controls and pattern definitions are exported as design material, so the editor can render them and AI can understand them.

Full control

Smart filters

You don't need to sync your entire KB. KB Sync lets you define exactly which objects to export and import.

Scope (Objects)

Define which modules, folders or object types you want to sync. If empty, everything is synced.

Exclusions (Exclude)

Exclude specific objects within the scope — ideal for temporary or test objects.

Forced inclusion (Include)

Force the inclusion of objects that would otherwise be excluded. Highest priority.

Practical example

Sync the entire Sales module except temporary procedures, but always including Sales.TempImport:

Objects

Module = Sales

Exclude

Procedure = Sales.Temp*

Include

Procedure = Sales.TempImport

Organization

Your project, organized

KB Sync generates a clear, predictable directory structure that mirrors your Knowledge Base's organization — and keeps it that way: move or rename a folder or module in GeneXus and the externalized directory moves with it.

ProjectRoot/
├── .kbbridge-sync/              ← Synchronization metadata
├── ai/                          ← Documentation for AI tools
│   ├── kbbridge/                ← GeneXus language reference
│   │   └── genexus-properties/  ← Property catalog per object type
│   ├── CLAUDE.md
│   └── start-here.md
├── Knowledge Base/              ← All GeneXus objects
│   ├── @ModuleName/             ← Modules (namespace)
│   │   ├── @SubModule/          ← Nested modules
│   │   ├── #Domains/            ← Module domains
│   │   ├── MyProc.Procedure.gxSource
│   │   ├── MyProc.Procedure.gxLayout
│   │   ├── Customer.Transaction.gxSource
│   │   └── Customer.Transaction.gxForm
│   ├── #Attributes/             ← Global attributes
│   ├── #Domains/                ← Global domains
│   ├── #Files/                  ← File objects and their attachments
│   └── #Tables/                 ← Tables (editable indexes)
├── Patterns/                    ← Pattern definitions
└── User Controls/               ← User Controls (design files)

@ = Module

Directories with @ represent GeneXus modules (namespaces). Unlimited nesting supported.

# = System

Folders with # are system folders: Attributes, Domains, Tables, Files. They should not be modified manually.

. = Hidden children

Folders with . contain child objects of transactions and pattern instances, organized automatically.

Collaboration

Team development, solved

KB Sync was designed for teams. Each developer works with their own change files, and the engine coordinates everything.

Multi-user flow

1.A developer edits a file with KB Editor or an AI tool
2.The change is automatically recorded in their personal tracking file
3.KB Sync detects the change and imports it into the Knowledge Base — a moved or renamed object travels as a single change, not a delete plus a create
4.If another developer changes something in GeneXus, KB Sync exports it automatically
5.Every developer sees the changes reflected in their files, and each one sees the build result of their own changes

Automatic validation

Every change KB Sync imports goes through a complete validation process before writing to the Knowledge Base:

✦Parsing and verification of the file structure
✦Validation of referenced data types
✦GeneXus internal validation
✦Application in dependency order, with a retry pass at the end of every cycle
✦Detailed report with section, line and column on error

Errors don't stop the synchronization. The change is flagged as an error, the modified file is protected from being overwritten, and the developer can fix it and save again — or discard the local changes from KB Editor and re-export the object from the KB.

Flexible

Configuration your way

Each Knowledge Base is configured independently. Multiple KBs, different GeneXus versions, different sync and build rules.

Multi-version GeneXus

Supports GeneXus X, X Evo1/2/3, 15, 16, 17 and 18. Auto-detects the installation from the Windows registry.

Configurable cycles

Tune the sync interval (default: 10 s), the lookback window and retention limits.

Automatic build

Enable a build after every sync that imports objects, choose its scope and how many quiet cycles to wait before building the batch.

Build environment

Leave it open so each developer picks from KB Editor, or lock it from the Manager so everyone builds against the same one.

Auto-start

Set KBs to start automatically when the Manager opens, or even when Windows boots.

Administrator mode

For KBs in protected paths (Program Files). Runs the synchronization with elevated privileges via UAC.

Long paths

Support for paths longer than 260 characters — needed when the module structure produces deep paths.

Live console

Monitor synchronization and builds on separate channels, with auto-scroll, search, noise filtering and copy/clear options.

AI documentation

Choose which context files for AI tools are deployed into the project and keep them current on every release.

Simple

Install in minutes

One installer, everything included. No external dependencies, no manual runtime configuration.

Included in the installer

✦KB Sync Manager (self-contained executable, no .NET required)
✦Engine binaries for every supported GeneXus version, from X to 18
✦Documentation for AI tools, ready to deploy into the project
✦Start-with-Windows options and desktop shortcut
✦Multi-language support: English, Spanish, Portuguese
✦Automatic new-version notice and detection of running instances during upgrade

Requirements

✦Windows 10/11 or Windows Server
✦GeneXus X, X Evo1/2/3, 15, 16, 17 or 18 installed
✦Access to the Knowledge Base
✦15-day free trial — no credit card

Free your GeneXus code

Stop being limited by the GeneXus IDE. With KB Sync, your Knowledge Base becomes text files you can version, share and supercharge with artificial intelligence — and compile without leaving your editor.

For developers

Edit with KB Editor, use AI, build from the editor and version with Git. All without leaving GeneXus.

For teams

Real collaboration with text files, per-user change tracking, automatic validation and builds attributed to each developer.

For organizations

Simple installation, Windows Server support, and compatibility with every GeneXus version from X to 18.

For the ecosystem

A bridge between the power of GeneXus and the modern tools today's developers expect.

Download now View pricing View KB Editor