
The developer who built your Clarion system has retired, moved on or stopped answering email. The software still runs, your team still depends on it, and nobody on staff knows how it works inside.
This is more common than most owners expect, and it is manageable. The first few weeks matter, though. The wrong move, such as a well-meant "cleanup" or an operating system upgrade, can turn a quiet risk into an outage. This guide covers what to do first, in order.
Step 1: Change nothing, then protect what you have
If the system is working today, your first job is to keep it that way. Resist the urge to update Windows, move the application to a new server, reorganize folders or "tidy up" old files. Each of those is reasonable on its own. Each can break a system that nobody fully understands.
Then make sure you have a safe copy of everything:
- The program folder, including the executable (.EXE) and any supporting files (.DLL files, reports, configuration and INI files).
- The data folder, including every TopSpeed (.TPS) data file.
- Anything the program reads or writes outside those folders, such as export folders, scheduled import files and shared network drives.
Copy these to a separate location that is not the same machine or disk. Keep the first copy untouched and label it with the date. If you later need to experiment or attempt a repair, work on a second copy, never the only one. If your data files are in use when you copy them, the copy can be inconsistent, so do the copy when everyone is out of the program, or ask someone experienced how to take a safe copy of your setup.
Step 2: Look for the source code
The running program (the .EXE) is not the same thing as the source code. Without the source, the program can usually keep running, but it cannot be properly changed, fixed or rebuilt. Finding the source is the single most valuable thing you can do.
Clarion source usually lives in a few recognizable file types:
- .APP files hold the application as designed in Clarion.
- .DCT files hold the data dictionary, which describes your tables, fields and keys.
- .CLW and .INC files hold hand-written and generated source code.
- .SLN and .CWPROJ files appear in newer Clarion versions as project files.
- .TXA files are text exports of an application, sometimes kept as a safety copy.
Where to look, in rough order of likelihood:
- The developer's old computer, if it is still in your office or a closet.
- The server, including folders named things like "Source", "Dev", "Clarion", "Old" or "Backup".
- Backup drives, cloud storage and archived email, since developers often send zip files of the source after a major release.
- Your IT provider, who may have taken backups of a development machine years ago.
- The developer, if you can reach them. A polite request through a mutual contact or former colleague is worth the effort. Ask for the source, the Clarion version used and any third-party tools the project needs.
Do not assume that a folder full of source files is complete or current. Note the dates on the files and compare them with when the live program was last updated. If the source is older than the running program, it may be missing recent changes.
If you cannot find any source code, that is a serious problem but not the end of the road. A specialist can often work out how the system behaves by studying the data, the screens, the reports and the program itself, and can advise you on the realistic options.
Step 3: Identify what the system depends on
Legacy systems rarely stand alone. They lean on things that were set up years ago and may not be written down anywhere. Make a simple inventory of:
- The Clarion version the program was built with. Different versions behave differently, and the right version is needed to rebuild the program.
- Third-party templates and libraries. Many Clarion programs rely on add-on tools for reports, grids, email, scheduling or other features. If the add-on is missing, the source may not compile even when you have it.
- The machines it runs on. Which Windows versions, which server, which workstations, and which printers. Note anything that must stay the same.
- Where the data lives and how users reach it, such as mapped drives or shared folders.
- Connections to other systems, such as accounting software, spreadsheets, label printers, scanners, barcode devices or file exchanges with customers and suppliers.
- Scheduled or background jobs, such as nightly exports, backups, imports or email runs.
- Licenses and keys for the program and its add-ons, including any hardware keys.
Sit with the people who use the system every day and ask them to walk you through their routine. They will mention things like "on the first of the month I run this report and email it to the accountant", which never appears in any technical document.
Step 4: Capture the business knowledge
Years of custom decisions are baked into your software: how discounts are calculated, which customers get which terms, how an invoice is numbered, what happens when stock runs out. These are your business rules, and they are often the most valuable part of the system. They are also the part most likely to be lost, because they live partly in the code and partly in the heads of long-time employees.
You can start capturing them now, before any technical work begins:
- Ask your most experienced users to record short screen recordings or take screenshots of their key tasks, such as taking an order, closing the month or issuing a refund.
- Save sample outputs: printed invoices, reports, statements, labels and exported files, along with the situation that produced each one.
- List the "unwritten rules" and exceptions. Ask, "What do we do for the customer who is always handled differently?"
- Note known glitches and workarounds. If staff avoid a certain button or restart the program every afternoon, write it down.
This material helps whoever supports the system next, and it is one of the best defenses against a failed replacement project later. Replacement projects often stumble because the new system does not reproduce rules nobody remembered to mention.
Step 5: Get a second set of eyes before making big decisions
Once your data is safe, the source is located or confirmed missing, and you have a rough inventory, you are in a good position to decide what comes next. The options usually include stabilizing the existing system, setting up ongoing support, connecting it to modern tools, or modernizing in phases. A full rewrite is only one option among several, and it is rarely the right first step.
Be cautious with anyone who recommends starting over before they have examined how your current system works. Stabilizing first, understanding what you have and then changing it in small, testable steps keeps your business running while you improve it.
A short checklist to start today
- Do not upgrade, move or rearrange anything yet.
- Make a dated copy of the program folder and all data files to a separate location.
- Search the server, backups and old computers for source files.
- List the software, machines, add-ons and outside systems the program relies on.
- Ask your longest-serving users to document how they use it.
- Talk to someone who works with Clarion before deciding on a repair or a replacement.
Need help with a Clarion system and no developer?
At Clarion Programming Help, we work with Clarion systems when the original developer is no longer available. Our approach is to stabilize first, preserve your business rules, and modernize in phases only when it makes sense for you. If you are looking at an unsupported Clarion application and are not sure where to start, Contact Us and tell us about your situation.
