How deep does this library reach into the the OS? I’m searching for something I can use from microcontroller code, where there isn’t full POSIX or Win32 support.

My programming career literally started in a dumpster in the ’90s, when I found a Turbo Vision book someone had thrown away. I picked it up and immediately fell in love with the bluish TUIs that anyone could make.

How awesome to see this on the front page! I've been writing a wrapper for this repo. Right now I'm running Turbo Vision -- this repo -- under .Net on macOS. It's a magical feeling.

The wrapper gives a higher level API, and solves some of the things like the rather antique palette API (or wraps it), is adding layout, etc.

```

var lMenuBar := new MenuBar;

  lMenuBar

    .Add(lDocumentMenu)

    .Add(lViewMenu)

    .Add(lDialogsMenu)

    .Add(new Menu('~A~pp').AddItem('E~x~it', Commands.Quit));

  fApplication.SetMenuBar(lMenuBar);

(This is Oxygene, currently compiling to .Net. Can be used from any .Net language of course, even Go or Swift with our toolchain, but as an assembly, consumed by anything. Using PInvoke for the native TV binaries.)

Heavily in progress :D The repo is still private and I'm working on things like basing palettes on the surfaces controls are placed on today and tomorrow. Todos are cleaning up layouts, adding a few more basic (for today) missing controls, etc.

I had experimented with libraries like Terminal.GUI, which was (still is?) in the middle of a v2 transition and really difficult to get behaving without bugs. And Claude is a great lesson about TUIs and libraries that have been built without real terminal consideration -- lots of what not to do. I found myself missing Turbo Vision and thinking, why not just have a modern version? Then I found this repo, saw it was updated for Unicode, etc... I am very grateful to the author.

• magicalhippo

  today at 8:13 AM

  > This is Oxygene

  For those who aren't familiar[1], it's part of RemObjects' Elements[2] suite, which allows you to use and mix several different popular languages in addition to the Pascal-based Oxygene across Windows, MacOS, Linux, Android etc.

  [1]: https://www.remobjects.com/elements/oxygene/

  [2]: https://www.remobjects.com/elements/

• lepicz

  today at 12:08 PM

  > It's a magical feeling.

  hehe working with this TV library scratches my nostalgia itch :D

  it probably saved me from futile efforts like writing apps for GEOS or joining the one person Hurd team.

• actionfromafar

  today at 9:16 AM

  I wanted to do the same. I have used Terminal.Gui but would prefer TV and so considered a wrapper. Would be really interesting to see your wrapper.

Supercool .. the universe of possibilities really exploded when Borland came out with Turbo Pascal compiler, Turbo C++ and TurboVision.

Compiler performance was superb and the manuals were a work of art - I just wished I had kept all of mine.

This is a cultural treasure.

• JimDabell

  today at 6:18 AM

  The manuals were great. I taught myself C/C++ in the early 90s mostly from the big stack of Borland books that came with Turbo C++. It’s hard to imagine learning something like that these days by simply sitting down and reading reference manuals.

  • WillAdams

    today at 1:00 PM

    Towards that end, I've been trying to put together a list of Literate Programming texts:

    https://www.goodreads.com/review/list/21394355-william-adams...

    I really wish that there were more, in particular, I'd dearly love to see a graphical QT (or other up-to-date) GUI app as a Literate Program.

  • pjmlp

    today at 7:22 AM

    Me as well, as a teenager those manuals were invaluable, it wasn't as if we could easily learn elsewhere.

    It was either the manuals, or getting lucky with magazine articles or local library book selection.

• unj

  today at 5:13 AM

  Turbo Vision for a long time was for me like a golden standard. All the new TUI frameworks seemed like they were missing something.

  Now I will get to see if that was just a nostalgia. Gonna use this in the next tool. Huge kudos to the authors <3

• pjmlp

  today at 6:32 AM

  Indeed, except for GW-BASIC and MS-DOS, for me it was Borland all the way.

  Turbo BASIC, Turbo Pascal, Turbo C++ for MS-DOS and Windows 3.x, Turbo Vision and OWL.

  Got into VC+ on version 5, and MFC always felt so lame compared with Borland offerings.

  To this day, they don't have anything that can match C++ Builder RAD capabilities, and even with the historic background, it has taken a few years for .NET to get the low level coding and AOT story straight, Delphi like.

  We should give Go, C++ and Rust folks a few copies of Turbo Pascal 7 for MS-DOS, and Delphi current.

it is still very well usable - i used TV 2.0 year ago to do some prototype. i wanted (and mostly succeeded) to create turbovision front end for LLDB debugger... you know, that would behave like Borland's Turbo Debugger.

few quick notes:

- blimey it was like it where i left it 199x :) you can even compile/run code from 1993 without major issues.

- there's even a better internal TV editor based on scintilla, so with syntax highlighting and such. although i was trying to mod it without success, i'll have to ask author for help, probably.

- there's no documentation (in the sense of common wisdom), so you can't ask stack overflow or AI. you have to do it like in old days: learn from examples (that have bugs in them ;) and read those few books on turbo vision again and again.

- manual 'layouting' is kinda annoying, some auto layout like qt would be handy

- i miss splitters, but that should not be hard to implement

- tbh i am kinda surprised how small and compact TV really is. it felt ginormous in the 90ies :)

overall - the author did very good job modernizing the library and i love it.

• Narishma

  today at 9:14 AM

  > there's no documentation (in the sense of common wisdom), so you can't ask stack overflow or AI. you have to do it like in old days: learn from examples (that have bugs in them ;) and read those few books on turbo vision again and again.

  Not sure what you mean here. Turbo Vision came with extensive high quality documentation. If anything such documentation is what's lacking nowadays.

  https://archive.org/details/bitsavers_borlandTurrogrammingGu...

  • today at 12:10 PM

  • lepicz

    today at 11:20 AM

    i mean: for example you have a problem 'how do i create scrollbars two squares wide' (not a real problem, can't think of something now)

    if you work with qt for example so these days you ask google/stackoverflow/qtforum and you have multitude of responses if it's a common problem and sometimes you have whole solutions ready to copy&paste.

    when you work with TV and ask google - you usually get... not much. so you have to take the longer route: study the doc/books (you mentioned), study the code, examples... or be friend with the author of this library or those two or three people who actively use this library these days ;)

    -- edit: btw those books (there's a c++ one as well) you mention are good, but, sadly, no book is detailed enough when you have very specific problem :)

The original version came with Turbo Pascal 6, the C++ port came later.

So this is a modern port of the port. :)

Borland did the same with other frameworks OWL came first in Turbo Pascal for Windows 1.5, and many of C++ Builder tools are actually written in Delphi.

Anyway, Turbo Pascal 5.5 adoption of Object Pascal, followed by Turbo Vision on version 6, was my introduction to OOP, and it I was lucky have gone that path.

Got to learn OOP, and all the goodies that Turbo Vision offered as a framework in an environment like MS-DOS.

• badsectoracula

  today at 9:14 AM

  Amusingly, Free Vision (the Free Pascal version of Turbo Vision) is based on a manual translation of the C++ version because that was released on public domain at some point and someone ported it back from C++ to Object/Free Pascal.

  • pjmlp

    today at 9:36 AM

    Interesting. If I remember correctly the source code was available (need to check my old disks), however most likely the licence would forbid that anyway.

    • badsectoracula

      today at 9:53 AM

      IIRC Borland released the C++ version specifically as PD later on their FTP server, it isn't based on the version from Turbo C++ physical releases. The history is (very briefly) mentioned in the Free Vision wiki page at the FPC wiki[0] (note that the wiki needs cleanup, e.g. it mentions 64bit clean support as a todo item but FV has been 64bit clean for a very long time now). It also mentions that somewhere between the C++ version and the Pascal conversion, TV/FV was converted to use graphics instead of text mode and it was ported back to text mode -- considering all the conversions, i'm surprised the API remained largely the same so that even now the best way to learn Free Vision is to read Turbo Vision docs/tutorials/books :-P.

      [0] https://wiki.freepascal.org/Free_Vision

      • pjmlp

        today at 10:00 AM

        I see, thanks for the clarification.

• rbanffy

  today at 9:43 AM

  OWL was really ahead of its time.

  • pjmlp

    today at 10:06 AM

    Yeah, besides the current offerings from VCL and FireMonkey, only Qt compares to it in terms of existing C++ frameworks.

    History rumor hill goes that originally MFC was just as high level, the origin of Afx prefix, however internal teams were opposed to it and hence how MFC became a very thin layer over Win32.

    History repeated itself with C++/CX, finally Microsoft had something comparable to C++ Builder, and internal teams weren't happy until they sabotaged the whole effort with C++/WinRT. Now outside Windows team no one cares.

    The development experience with OWL, on Windows 3.1 was great, I never bothered with raw Win16 or Win32 other that learning the foundations, or adding support for missing capabilities, at the TP, Delphi, C++ frameworks.

This is one of many Turbo Vision ports/clones.

There's also this one in C++: https://github.com/kloczek/tvision

The one that comes with FreePascal/Lazarus is written in Pascal.

There's even one in Rust, though it might have been vibe-coded: https://github.com/aovestdipaperino/turbo-vision-4-rust

So funny to see all the cmake instructions. Really makes you want to go back in time. Turbo C or Pascal, hit F9 and you're up and running.

It does showcase our incompetence. In this age we should be able to point to some online compiler and run it. Or download it and run it on a folder. That should be the extent of our involvement with tools. But apparently they are not tools, but rituals we insist on.

• rbanffy

  today at 9:42 AM

  Compiling software in modern unix systems used to be a solved problem: “./configure && make && make install” should always be the gold standard.

  • akoboldfrying

    today at 11:46 AM

    > solved problem

    autotools is horrifying. I'm not claiming that there is an obviously better way to solve the problem that it tries to solve, but it is horrifying.

    FTR, I have much more experience with cmake, which is also horrifying. (Maybe there is no non-horrifying way to solve this problem?)

    • badsectoracula

      today at 12:04 PM

      GP most likely meant it was a solved problem from the user's perspective. Autotools might be "horrifying" for the programmer (IMO that is an exaggeration, AT isn't that bad, with the potential exception of libtool) but it provides by far the best UX for a user (that knows how to use a command line and what building from code is, not your average grandma :-P) compared to everything else out there.

      However one important aspect here is that there is no reason for Autotools to be what provides the `./configure && make && make install` UX - the GNU standards (not sure the exact name) describe the UX itself without mentioning anything about Autotools so any other approach to implementing it would be just as valid. However in practice whenever you find a configure script in the wild it is either Autotools or a hand-made one (that more often that not misses some of the GNU standard stuff).

      • rbanffy

        today at 12:12 PM

        Autotools can be daunting if you plan to write code that’s portable to Ultrix, IRIX, Apollo’s UNIX whose name I forgot, NonStop, UNICOS, OpenVMS, z/OS, macOS, and modern Linux.

        Nowadays we don’t bother supporting dozens of platforms. Even Windows is something we can push aside and suggest WSL if you really need to run it under Windows.

        And I even try to make sure my code runs correctly on z/OS (which IS a UNIX).

A critical part that is somewhat lost when running this in a terminal is how the mouse behaved on a real text mode screen. It was a yellow block that you moved with the mouse not a mouse pointer.

Anyone tested to run this on a high resolution Linux text mode with GPM?

• Timwi

  today at 8:31 AM

  It wasn't inherently yellow, it was the inverse of whatever it was on top of, but since the main window filling most of the screen was dark blue, it looked bright yellow most of the time.

I’m happy it relies on libcursesw for terminal abstraction instead of hard-coding ANSI sequences. This way I can continue using my VT-100 compatible terminal.

I still need a VT-230 or 330.

I recommend the recent Wookash podcast with Chuck Jazdzewski, who was part of the team that created the original TV and much more in that ecosystem.

I am still wishing for the "real" Turbo Vision, the Pascal version because the C++ one is more like a port of the Pascal one.

"Uses" is keyword in Pascal, for example, so "including" a module by "#define"-ing feels like a "hack"

I guess it doesn't matter, nowadays.

• badsectoracula

  today at 9:11 AM

  Free Vision, included with Free Pascal is basically that. The text mode IDE[0] uses Free Vision.

  The main issue is that Free Vision (and Turbo Vision) uses the original "object" types introduced in Turbo Pascal 5.5 instead of "class" types introduced in Delphi which make a lot of things easier (e.g. the "class" RTTI allows for enough reflection to implement automatic serialization of objects, but "object" types do not have that and Free/Turbo Vision require manual serialization with registration of the VMT pointer -accessed via a fixed offset in object pointers- as a means to distinguish at runtime between different types). Free Pascal adds a few of the niceties of "class" types to "object" types (like private/protected/public sections -TP objects are all public- and properties) but Free Vision doesn't use those as it implements the original Turbo Vision API.

  [0] https://wiki.lazarus.freepascal.org/images/1/19/Userscreen.p...

Hmm this is based on the original turbo vision source code. I wonder if Embarcadero or whoever owns the corpse of Borland this week can find a reason to complain.

A good related post & discussion to this for various memory lanes:

IDEs we had 30 years ago and lost (2023)

https://news.ycombinator.com/item?id=45626910

Warm memories... I had an idea to do that on rust

DOS still a target. Respect.

See also Final Cut

https://github.com/gansm/finalcut

• vintagedave

  today at 8:13 AM

  That looks really neat! I was surprised by the major Windows 3.x vibes.

  • spankibalt

    today at 9:38 AM

    Microsoft's DOS Shell is closer to the mark. [1]

    1. [https://en.wikipedia.org/wiki/DOS_Shell#/media/File:DOS_Shel...]

  • rbanffy

    today at 9:49 AM

    I really hate that VGA looking font. That IBM went with serifs by default on the MDA and all subsequent PC fonts is a disgrace. They had a much nicer one in their mainframe and mini terminals.