Profan

Profan is a German programming language for Microsoft Windows that its author, Roland G. Hülsmann, first released as shareware in the middle of 1992 and last updated in September 2018. Its name is a pun - Programmieren für Anwender, “programming for users”, and profan, the everyday as opposed to the sacred - and the pun is the design brief. In 1991 and 1992, Hülsmann wrote later, putting a window on the screen and drawing a line in it took several pages of C or Turbo Pascal for Windows: a window procedure, a message loop, a device context, a pen and a brush, and a repaint handler so the line did not vanish when the window moved. Coming from Turbo Basic and Turbo Pascal, “I said to myself: it must be possible to do this more simply. The way it used to be in BASIC: a CLS and then a LINE.” Profan is that idea carried through for twenty-six years.

The language went through three names. Profan 1.x (1992) ran on Windows 3.0 and had integer arithmetic only. Profan² - versions 2 through 7, 1993 to 2002 - added floating point, dialogs, dBase and ODBC databases, multimedia, a 32-bit edition and text-mode ports to DOS, OS/2, Linux and even the Atari Portfolio. XProfan (“extended Profan”), from version 8 in November 2003 to X4 in May 2018, added classes and objects, compiled units, OpenGL, a modern variable syntax, Unicode strings, SQL databases, JSON and an inline assembler. Throughout, the product was the same three programs: an interpreter for developing and for “batch” scripting, a compiler that turns source into a compact bytecode file (.PRC), and a linker that glues that bytecode to a runtime module to make a stand-alone .EXE. The master-list entry that brought Profan to this site - 1991, procedural, systems programming, dormant - is right about the paradigm and the dormancy, a year early on the release, and wrong about the category: Profan was never a systems language and its author said so; it was an applications, database and games language for people who did not want to learn the Windows API.

History and Origins

Nußloch, 1992

Roland G. Hülsmann ran a one-person software business, RGH-Soft, from the small town of Nußloch south of Heidelberg; the 1997 manual gives a street address there, and the site’s Impressum has named Nußloch addresses ever since. His background, by his own account, was in Turbo Basic, Turbo Pascal and the dBase-compatible language Clipper, in which he had written his own customer-management system. What he wanted in 1991-92 was the immediacy of home-computer BASIC on the new graphical platform, and what he wrote was an interpreter whose WINDOW, CLS, LINE, PRINT and INPUT opened a real Windows window, handled its painting and message queue behind the scenes, and let the programmer think about the program. Profan 1.3/1.4 went out as shareware in mid-1992; the copyright line in later manuals runs “1992-1997”. Two secondary sources give other dates - the German Wikipedia article says the first version appeared in 1990, and the language catalogue this site follows says 1991 - but neither cites anything, and Hülsmann’s own 2009 account, which places both the frustration and the release in “1991/92” and “Mitte 1992”, is the only first-hand statement.

Wikipedia also records that a hard-disk crash destroyed the first version, so that it was redeveloped as Profan². That story is unsourced too, but it is consistent with the manual, which treats 1.x as a distinct ancestor with its own compatibility notes (“Profan 1.x only had integer arithmetic”, “the MessageBox command still exists for compatibility with Profan 1.x”) and documents source compatibility only from 2.x onward. The superscript ² was part of the product name until 2003 and survives in file names and forum handles to this day.

Profan² 2 to 6: a shareware product grows up

The 6.0 manual is the best record of the 1990s, because Hülsmann noted in it which version introduced what. Version 2.0 dropped Windows 3.0 and required 3.1. Version 3.0 brought user-designed dialogs and a new bytecode format, and every runtime since has been able to load PRC files back to 3.0. Version 3.2 added an ODBC interface alongside the built-in dBase III support, 3.3 bitmap loading and saving, 4.0 the serial port, 4.1 long file names under Windows 95 and the $O+ preprocessor that finally allowed infix operators, 4.2 memo fields, 4.5 (the version that, a user recalls, reached many people on a Pearl CD) and 4.5a a FONT command, and 5.0 access to resources stored in DLLs and EXEs. PROFAN² 6.0, dated 1997, came as two source-compatible editions - a 16-bit one for Windows 3.x, tested as far as Windows NT 3.1 and OS/2 Warp 3, and a 32-bit one for Windows 95 and NT 4 - with identical bytecode, so that the same compiled program could be started by either runtime. It shipped with the interpreter (PROFAN.EXE, or SHPROFAN.EXE in the shareware edition), an editor (PROFED.EXE), the compiler and linker, two runtimes, a set of “Helfer” wizards for building dialogs and menus, a demo program written in Profan and a 341-page manual in three parts: introduction, programming course and reference.

The manual’s opening page states the goals: “a simple syntax, based on BASIC, also for the beginner; traditional procedural (not object-oriented) programming; all the graphics capabilities Windows offers; extensive file and management functions; the complete program in one file that is not too big; no further DLLs or other files; the possibility of passing on applications at no further cost.” The last two were commercial arguments against Visual Basic, whose runtime DLLs had to travel with every program. The 6.0 manual put the runtime module at “not even 250 KB”, so that “quite elaborate Windows applications under 300 KB” were possible - a complete application still fitted on a floppy disk.

profan.de, the mailing list and the ports (1998-2002)

The language had a web site and a forum by 1998 (the first forum archive ends on 6 May 1998) and a mailing list by early 1999 at the latest; by 2000 the front page of profan.de linked to the list, a “PROFAN-SUPER-PAGE” and a forum hosted in Berlin, and an internet-service company ran what it called “the somewhat different PROFAN shop”. Between October 1998 and December 2000 Hülsmann released free text-mode “PROFAN-CONSOLE” builds for OS/2 Warp, 16-bit DOS “from XT with 640 KB”, the Atari Portfolio palmtop, Linux and finally 32-bit DPMI DOS. They were real ports of the runtime, not toys: because the compiler produced platform-independent bytecode, a program compiled on Windows could be run by the Linux or DOS runtime of the same version, and the 2009 introduction still advertised “one program on the server, any clients”. The OS/2 and Portfolio ports were marked “development discontinued” within the year; the DOS and Linux ones were advertised on the home page until 2010 and are still downloadable.

PROFAN 7.0 was the first version sold on CD with a printed manual through the mail-order house JDS Software: shipping began on 7 July 2000 at 149 DM, or 59 DM as an update from 6.x, with a bugfix 7.0a on 26 July that also made programs “about 10% faster”. Version 7.5 was finished on 21 December 2001 and 7.6 on 24 December 2002; 7.6 later became the free version once 8 was out. In February 2003 Hülsmann moved the community onto a PHP forum on his own server, rgh-soft.de/forum01, whose PROFAN NEWS board is the most reliable dated record of everything that followed.

XProfan (2003-2018)

The step to XProfan was planned in public. In May 2003 an “Early Bird” programme invited add-on authors to prepare for a version that could compile include files into “compiled, compressed and encrypted units”, so that library writers no longer had to ship source. On 15 September 2003 a subscription limited to 50 buyers opened for the pre-release; on 21 December Hülsmann announced that XProfan 8.0, release date 13 November 2003, had gone to the master CD. “XProfan? Is that still Profan? The X stands for extended… The essential extension is the possibility of programming object-oriented in Profan too. Profan² became XProfan!” Nobody, he added, was forced to use objects. JDS began shipping on 6 February 2004 at 59.90 euros, a shareware version followed on 6 April, and the pattern - subscription, master CD, JDS mailing, free patches, the version-before-last turned freeware - repeated for every release afterwards: XProfan 9 (release date 20 May 2005), 10 (subscription from March 2006, shipped around April 2007, with OpenGL built in), 11 (subscription from 10 October 2007, current by late 2008), X2 (release date 4 April 2011), X3 (summer 2015) and X4 (13 May 2018). The odd numbering - 12, 13 and 14 were sold as X2, X3 and X4 - began with the 2010 subscription, which was still announced as “XProfan 12”.

Prices barely moved in some fifteen years: a full version cost 59.90 euros from 2004 to 2018, updates 19.90 to 39.90, subscriptions around 20. Hülsmann described the system in 2015 as “the same for a long time and price-stable: current version x about 60 euros, x-1 about 40, x-2 about 25, x-3 a free full version” - which is why XProfan 8.0a, 9.1, 10.0a and 11.2a became freeware in 2009, 2012, 2015 and 2018 respectively.

After X4

The X4a patch of 8 September 2018 was the last release. The news board was touched once more in May 2021; the front page of xprofan.de still reads “Mai 2018: XProfan X4 ist fertig!”. In forum threads of 2023 and 2024 long-time users noted that Hülsmann, who used to read the forums daily, had not been seen for months, that he was understood to be caring for elderly parents, that XProfan was still 32-bit-only in a world where 32-bit Windows was disappearing, and that the FreeProfan source code he had promised to publish in 2015 had never appeared. A poll on interest in a “Version X5” was started in October 2021 and was still being answered in 2024, but there is no X5. Dormant is the right word.

Design Philosophy

BASIC surface, Windows underneath

A Profan program looks like structured BASIC. Statements are one per line (the manual makes a virtue of this: “structured and clear programming is made possible by allowing only one command per line”), control structures are If ... ElseIf ... Else ... EndIf, Case, While ... EndWhile and later Repeat ... Until, Select ... Case and For ... EndFor, and there is no THEN. GOTO, GOSUB and labels existed for compatibility and were deprecated by 2004. Procedures are Proc name ... EndProc with a Parameters line, “as in Pascal”, and have local variables; user functions are declared with Def. Variables must be declared before use and carry BASIC sigils that fix their type - Name$, Count%, Big&, Value!, Buffer#.

What made it a Windows language was the runtime. Every Profan program is a genuine Windows application with a main window, a message loop and repainting handled by the runtime; the programmer sees Window, WindowTitle, WindowStyle, Cls, Print, Locate, DrawText, UsePen, UseBrush, Rectangle, Ellipse, LoadBmp, Create("Button", ...) and WaitInput, and never a WndProc. Dialog elements, menus, list boxes, file dialogs, the clipboard, DDE, SendMessage, SendKey to drive other programs, MCI multimedia (WAV, MIDI, CD audio, Video for Windows), the serial port, INI files and, on 32-bit Windows, the registry were all built in. When the built-ins ran out, @UseDll and external function declarations reached any Windows API or DLL, and from version 11 callback procedures let APIs that need a callback address be used even in the interpreter.

Functions instead of operators

The most surprising thing about early Profan is that it had no operators. “Operators as one knows them from other languages normally do not exist in PROFAN. Everything is done by means of functions”: LET A% = @ADD(A%,3) instead of A% = A% + 3, IF @EQU(A%,B%) instead of IF A% = B%, @AND, @LT, @GT, @NEQ$ for strings, and so on. The @ prefix marked a function call and, the manual noted, made the interpreter faster because it knew at once that a function was coming. Version 4.1 added the $O+ preprocessor, which rewrites (A% + B%) into @ADD(A%,B%) before execution - at a cost of “up to 50% slower” interpretation, with every operator expression required in parentheses and only two operands per pair, so that (B% + C% + D%) had to be written ((B% + C%) + D%). Later versions made operators native and relaxed the syntax, and XProfan X2 in 2011 introduced a second, sigil-free declaration form (Declare int zahl, Parameters long A) alongside the old one; but the function-first design explains the shape of the language’s enormous library, in which almost everything, from @LoadFile$ to oGL("Sphere", ...) and JSON("..."), is a function, and the newer “container functions” (Set(), DB(), FTP(), SMTP(), COM(), Res()) multiplex dozens of operations behind one name and a string selector.

The Bereich

Profan’s one original data type is the Bereich (area), sigil #: a block of memory allocated with Dim Buffer#, 32000, written and read by offset with Byte, Word, Long, Char and String commands and their @Byte(...)-style function twins, passed to API calls as a pointer, and freed with Dispose. The manual describes it as “a data type that offers the flexibility of pointers without their danger in use”, because every access is bounds-checked (on 16-bit Windows the limit was 64 KB). It is how Profan programs talk to structures, buffers and DLLs without ever exposing a raw address, and it survived unchanged into XProfan, where Struct declarations were layered on top of it.

Interpreter, compiler, runtime

“PROFAN² contains both: interpreter and fast compiler!” The workflow was to develop in the interpreter with the TRACE mode (and later breakpoints and a debugger), then compile. The compiler does not produce machine code: it produces a compact bytecode in a .PRC file, and the linker (PROFLINK.EXE, later folded into the compiler) prepends a runtime module to make an EXE, optionally as a screen saver. The runtime is itself a bytecode interpreter, so - as the Wikipedia article and Hülsmann both say plainly - compiled XProfan is “considerably faster than the interpreter” but slower than C, PowerBASIC or Delphi, which emit native code. No published benchmark exists; the only quantified claim in the record is the 7.0a note of “about 10% faster”. The compensation Hülsmann offered was density: “page-long C++ source often needs only a few lines in XProfan”, especially for OpenGL, where oGL("Init"), oGL("Sphere", ...), oGL("Rotate", ...) and oGL("Show") replace the usual setup ritual. The bytecode design also gave the language its portability (the same PRC ran on the DOS, Linux and Windows runtimes) and its plug-in trick: a linked EXE can still act as a runtime for further PRC files, so an application can load modules at run time.

Speed-hungry users had two escape hatches, both from the community: Frank Abbing’s XPIA inline assembler and David Strutz’s XPSE precompiler, whose later versions compile marked procedures (“nProc”) to native code with JWasm. Hülsmann eventually built an inline assembler into X4 itself, with full documentation of the x86 registers and a supported subset of CPU and FPU instructions.

The Language

Hello World, 1997 and 2018

The 6.0 manual’s first program and the modern one differ only in idiom:

1
2
3
4
5
6
7
8

' PROFAN² 6.0 (1997) - first lesson of the 'Profan as a batch language' course
DECLARE Datei$, Antwort%
LET Datei$ = @LOADFILE$("Text laden","C:\DOKUS\*.DOK")
LET Antwort% = @MESSAGEBOX("Wollen Sie eine Sicherungskopie erstellen?","Frage",36)
IF @EQU(Antwort%,6)
  COPY Datei$ > "C:\DOKUS\KOPIE.DOK"
ENDIF
RUN @ADD$("NOTEPAD.EXE ",Datei$)

1
2
3
4

' XProfan (any version since 8)
Print "Hallo Welt"
WaitInput
End

or, as a Windows dialog with an OK button, simply MessageBox("Hallo Welt","Info",0). The first example is the opening lesson of the “Profan as a batch language” course: a file dialog, a yes/no message box whose style number 36 is the sum of button, icon and default constants, a copy, and a RUN that hands control to Notepad. The backslash continues a statement onto the next line; LET was mandatory in early versions.

Program structure

The manual prescribes a layout that XProfan programs still follow: a declaration section (Declare, Dim), $I include files, Def function definitions, procedures, then the main program beginning with WindowTitle, WindowStyle, Window and ending with End. Procedures may recurse; the 32-bit 6.0 runtime allowed 150 nested calls, the 16-bit one 50. Limits that mattered in 1997 - 32,767 program lines, 500 variables per type, 15 open files, 12 parameters per procedure - were removed in XProfan 11 (“Wegfall programmtechnischer Grenzen”) along with static memory management.

What each generation added

Community

For a commercial language with one author, Profan had an unusually active user base, entirely German-speaking. The mailing-list archives on the official download page run from the list’s start (the first archive, posted in February 1999, covers “from the beginning” to 22 February 1999) to 6 November 2003, and the forum archives cover five successive boards, the first ending on 6 May 1998 and the fifth on 5 February 2003, when the RGH-Soft PHP forum took over. David Strutz, a Berlin developer who posts as “iF”, built xprofan.com and later xprofan.net (2010) into a combined forum, code library, marketplace and documentation wiki - the online reference runs to hundreds of command pages - and wrote XPSE (2002), jProfan (2007) and the Android dialect Infinity-Profan (2015). Frank Abbing contributed XPIA and a stream of OpenGL demonstrations; Stefan Schnell maintained and extended the help files for roughly fifteen years (the 2003 news page already thanks him for them, and the 2018 X4 help file still carries his extensions); Michael Wodrich catalogued every command by group; Dietmar Horn reportedly organised “XProfaner-Treffen” user meetings in Lusatia around 2010 and 2012; Sebastian König wrote Profan2Cpp; and Paules-PC-Forum, a general Windows forum, has run an XProfan section since 2009 that is now, with xprofan.net and the old RGH forum, one of the three places where the remaining users meet. As of 2026 those forums are quieter but not silent: new threads on tray icons under Windows 11, Unicode, SQLite and a new precompiler (JRPC3, August 2025) suggest the language is still in use for the small utilities and in-house tools it was designed for.

Running Profan today

There is no Docker image and no open-source implementation. What exists, all from the official download page at xprofan.de and mirrored on xprofan.net:

• XProfan 11.2a (2009), a complete free full version with compiler that the download page lists for Windows 95/98/ME and NT/2000/XP/Vista/7/8/10; forum users report it still runs on Windows 11 as a 32-bit application.
• XProfan 10.0a, 9.1 and 8.0a, older free full versions.
• PROFAN 5.0b-16 for Windows 3.1x, free, for anyone with an emulator.
• PROFAN-CONSOLE 4.0 for DOS, OS/2 and Linux and 7.0 for 32-bit DOS, free text-mode runtimes; the DOS builds should run under DOSBox, though nobody appears to have documented doing so.
• FreeProfan 0.95 (2016), 32- and 64-bit builds of the X3-level interpreter, unsupported and, by user reports, unfinished.
• XProfan X4 itself is still sold for 59.90 euros through xprofan.net’s shop; whether orders are fulfilled in 2026 is unclear.

The community wiki noted that 32-bit XProfan programs can be run on Linux under Wine; the manual never promised it.

Why It Matters

Profan is a representative of a species that the English-language histories of programming mostly miss: the national-market commercial language. It was written by one person in a small German town, sold by mail order and on magazine cover discs, documented only in German, and used for twenty-five years by hobbyists, teachers, shareware authors and small businesses who wanted Windows programs without Visual Basic’s runtime, C’s ceremony or Delphi’s price. Its design choices - functions instead of operators, the bounds-checked Bereich instead of pointers, a runtime that hides the message loop, portable bytecode so that one compiled program could serve DOS, Linux and Windows clients - are a coherent answer to the question of what BASIC should have become on Windows, arrived at independently of the answers Microsoft and Borland gave.

It also illustrates how such a language ends. There was no acquisition, no fork, no deprecation notice: the subscription for the next version simply never opened, the promised source release never came, and the author, by then - forum members reckoned - past seventy and looking after his parents, stopped posting. What remains is a complete, working, free toolchain, a quarter-century of forum archives, and, presumably, a few thousand programs in German offices and on German hard disks that still start when double-clicked.