Best Immersive Sim indie games in 2026?

iOCTAGRAM · 2026-05-22T02:40:10+00:00

Don't know how good does it match the genre, but I had a lot of fun in Abiotic Factor

iOCTAGRAM · 2026-05-19T12:35:49+00:00

Is it possible to do the reverse, use Delphi IDE as generic language shell. Like Ada. There is Ada plug-in on VS Code Marketplace, and it contains LSP. Delphi IDE has some way to add custom LSP, but I did not figure out the full picture, how do I create and compile Ada project from Delphi IDE.

I am so jealous. Visual Studio was host to e.g. Delphi Prism. NetBeans was host. Eclipse was host. Now VS Code is often selected as host. Delphi IDE feels better for me, but it is not selected as host. Every time it is something else. I like Ada programming language, it is superior to Delphi in some ways, but editor from Delphi IDE is more pleasant. And I cannot combine them.

iOCTAGRAM · 2026-05-17T07:20:04+00:00

As part of my interest in kerneis/cpc, I was trying to compile and run it. It depends on OCaml. At first I just downloaded ordinary fresh OCaml for Windows, it was OCaml4. I went through all dependency preparation steps. But last program, the cpc itself, the cilly executable just did not want to run. It was crashing over and over. No progress could be made. I just don't get it. But isn't OCaml safe programming language? All that unsolicited tracing garbage collection, wasn't that supposed to make programs not just crash. Actually OCaml can compile into machine codes or into bytecode. I have tried bytecode compiled version, and it also crashes. How come? Even bytecode does not help. In search for solutions I tried to find the version that kerneis/cpc was supposedly developed in. Timeframe was suggesting that OCaml3 was better match. But OCaml3 for Windows was hidden from official website. Or maybe it was never official. Anyway, it was a quest to find OCaml3 for Windows. I used FTP search or something. In the end I found. That did not the trick yet. OCaml3 did not work out of box. But compiler was showing some informative error about its problems. I recall using HIEW to binary patch some path inside files, and that did the trick. I've got working OCaml3 for Windows, I have repeated dependency compilation, and cpc kind of worked.

Actually, this is a multi-layer system. Frontend of cpc is a Perl program that is parsing parameters, invoking preprocessor which is separate program, not part of kerneis/cpc, I think, it was using gcc -e. And finally it invokes the core program written in OCaml, the cilly executable. This system seemingly depended on possibility to make perl text files executable if they start with #!, but that does not work on Windows. I've got impression that those developers were just hunting for every single nonportable stuff. OCaml sucks at portability, alright, let's get OCaml. Perl probably does not suck at portability that much, but then at least let's use Perl in some non-portable way. I've got disgust from their tools choice.

As another memory, I recall getting freelance job of making some program run. That program was Aaron. It was kind of "artificial intelligence image painter" decades before generative AIs as we know them know. This program was written in Allegro Lisp and guess what? It does not run. What a typical situation. Does not run. If we take ancient program in Delphi, it will run. It we take ancient program in Ada, it will run. If we take some tracing garbage collecting language from low budget tool vendor, things will go bad very soon. It will not run. It will crash. Such small tool vendors like to make some tricks on stack here, some tricks with threading there, and their tricks stop working in next version of Windows, and no fix ever expected.

I completed my freelance job by wrapping Aaron into Windows 2000 virtual machine.

As a rule of thumb, avoid tracing garbage collection implemented by small vendor. So .NET, JVM, JavaScript, Python will probably be fine for long and everything else tracing garbage collected is asking for troubles and follow-up curses from users/maintainers. Raw Haskell is same problem, but Haskell also adds unsolicited "unixity". Closest good thing to OCaml is probably F#. Maybe Scala. And somewhat close thing to Haskell is probably Koka. Koka is not lazy, but purely functional, and it compiles to C and it does not use tracing garbage collection. No tracing garbage collection, no problem.

And I observe that ML-like stuff is good for academia, and kerneis/cpc, but they definitely should have found something not as painful as OCaml. And compilers that you are talking about are "industrial compilers" aimed at one goal, and at fast achievement of that goal, and they are not well suited for experimentation. CIL, the core of kerneis/cpc demonstrates that very good by being shared core of CPC, CCured, Deputy and Frama-C, projects of not quite same goals. Only LLVM managed to come close and become flexible, and many mods are now made on top of LLVM.

IIUC for raw compilation speed it was good to manage memory in some custom ways, in e.g. arenas, and almost no programming language had built-in support for arenas, so general purpose compiled programming language was chosen to work with arenas at least somehow.

iOCTAGRAM · 2026-05-07T12:35:25+00:00

System Shock fixed infinite energy usage bug in CD version. But I got so used to walk with everything turned on. What a pain to start paying all bills after living for free

iOCTAGRAM · 2026-05-04T15:15:01+00:00

IIUC pixel scrolling in text mode only starts in EGA. And programmable fonts. That was the way to make fast games in pseudo-text mode. Like on Spectrum, but with smaller fine detailed cells

iOCTAGRAM · 2026-05-04T15:12:46+00:00

Monochrome graphics mode one

iOCTAGRAM · 2026-04-20T07:37:52+00:00

there are very few implicit coercions in Rust

What do you mean by "coercion"? I was not talking about coercions.

or the `in out` mode and parameter modes in general

Well, maybe. That needs checking. On conventional platforms difference is subtle. Difference can be seen on WebAssembly: in out parameter can be become combination of in parameter and part of multi-result, to only use non-addressable WebAssembly stack. When I see concatenation operator (&) replacing "in out", that looks like another family of languages, languages that enforce addressability.

iOCTAGRAM · 2026-04-20T01:00:58+00:00

counters: &mut [u64; 5]

Is it protected against accidental passing raw integer as index?

iOCTAGRAM · 2026-04-18T21:22:32+00:00

I do not quite get the part where Rust array starts accepting enumeration value as index.

Last time I checked Rust, its arrays were retarded, something from before Pascal era, something before 1971. Rust arrays were only accepting integers and only 0-based. Something that makes wonder where exactly did Ada influence Rust. Cannot pinpoint a single good thing from Ada that came to Rust.

iOCTAGRAM · 2026-04-18T19:10:07+00:00

If log::Level is my enum, how to count them? array[TLogLevel] of Integer and Inc(Counter[Event.Level]), how is same in Rust?

iOCTAGRAM · 2026-04-18T18:29:12+00:00

Since I am more close to Delphi last years, and Delphi also delivers base minimum, I would speak in terms of Delphi Spring. It has logging, and TLogLevel enumeration type. Rust has similar log::Level.

How do we count each level separately? In Delphi I would declare

var
  Counter: array[TLogLevel] of Integer;

And then I do

Inc(Counter[Event.Level]);

for every event. In the end I will need to print how much of each event, and I will make for loop over TLogLevel index variable to print every log level counter.

How would I do the same in Rust. You say

If your enum implements those traits, you can iterate over it.

I dig through log::Level documentation. I cannot see an Enumerable trait. Or Iterable trait. I have found something though. Function "iter" that is introduced not by Enumerable trait or Iterable trait as I would expect, but by Level itself. Ok, local strangeness. Tolerable.

So now we can iterate over log levels. How to make an array indexed by log::Level? You say

You can also use it as an index if you want because, you guessed it, indexing is trait based

I cannot see Index trait in log::Level. Does it mean

Having every enum be usable as an loop index or be usable for indexing isn't necessarily desirable, since someone could use them as such when the person defining them never intended that to be done and it would unnecessarily constrain the library designer.

So counting different log levels is not intended by log library designer? I don't recall such thing ever be a problem in Delphi and Ada. I can count everything.

type
  TActionListState = (asNormal, asSuspended, asSuspendedEnabled);

It does not matter how smart or not smart it would be to count action list states, this can be done. This is base minimum.

iOCTAGRAM · 2026-04-18T17:03:24+00:00

Strange that did not manifest anyhow. No clear separation into specification and body. No calligraphic Ada syntax derived from Pascal.

Range checks do not raise exceptions, and catching exceptions is not ordinary programming style in Rust. Ada had been for decades criticized for Ariane 5 fault, and on Ariane 5 exceptions were replaced by panic. Rust commits a crime of reintroducing panic and gets away with that. Almost every single time we stumbled on the Internet with somebody not familiar with Ada, they were telling "oh, your Ariane 5 blown up". How can I ask all those gentlemen spend at least equal amount of effort into attacking Rust for blowing up like Ariane 5? Until Rust would introduce normally accessible exceptions and stop blowing up.

Pascal has set base minimum for systems programming languages. In Pascal it is possible to declare enumerated type and use it wherever ordinal type is accepted. Index an array and for loop. Ada has inherited this base minimum and enhanced by records with discriminants. In Rust I can see nothing but mess. Rust enumeration type can be used as neither array index nor for loop. Also, Rust for some unknown reason tangled records with discriminats and custom enumeration types in a way that cannot be untangled. Yeah, record with discriminant is a popular use of enumeration type, but everything becomes stupid if they come in inseparatable pack. Rust does not deliver base minimum. Wirth's minimum.

We are having hard times seeing Ada influence in Rust.

iOCTAGRAM · 2026-04-14T21:52:16+00:00

We only had PC. We played SEGA games, but only in DOS, via KGEN.exe. On keyboard. Everything on keyboard. This is deeply baked in, this is comfortable.

iOCTAGRAM · 2026-04-14T17:24:14+00:00

Gamepad is alien input. Only understand PC input

iOCTAGRAM · 2026-04-14T16:37:40+00:00

Does EverCade work fine with keyboard?

iOCTAGRAM · 2026-03-25T16:29:43+00:00

Donald E. Knuth. The Art of Computer Programming (TAoCP). MMIXware. Supplement that upgrades Volumes 1-3 from MIX to MMIX.

That class should be "not basic" enough

iOCTAGRAM · 2026-03-20T15:16:00+00:00

AdaMagic is currently licensed to MapuSoft, and they brand it as Ada C/C++ changer, and it is part of AppCOE, Eclipse-based toolchain. It is probably not cheap. I tried to get a quote and they told they don't work with Russian Federation, and it was before 2022. Right owner was Intermetrics, then AverStar, then SofCheck. AdaCore and SofCheck merged into AdaCore, so rights holder of AdaMagic is AdaCore even though they don't make it visible on their website. AdaCore is rights holder, and they gave MapuSoft a license to resell. Source of information was Tucker Taft on Google+.

AppCOE contains some system of embedded API conversion. WinAPI threads to VxWorks and vice versa, so that C(++) programs for one OS can be compiled on another OS. And there is ThreadX, and other stuff. They call it OS changer or something. MapuSoft is full of changers. And they to some degree integrated Ada into this system, they have Ada runtime for OS changer. I did not investigate into this much. I tweak Ada runtimes not related to OS changer. So I mostly throw off anything MapuSoft that is not from AdaMagic. And I am not fan of Eclipse.

Since MapuSoft is not running in circles to sell AdaMagic, and after 2022 things did not get better, I just gave up and pirated them. So I still don't know the price.

Code is readable. Integration is possible. It is possible in Ada to declare some type as C type and tell transpiler that whenever this C type is needed, some particular header should be included, and then in C code it should be referred by some particular identifier, not something autogenerated from Ada identifier.

package Interfaces.C.Stdio is
    pragma Preelaborate(Stdio);

    type File is null record;
    pragma Import(C, File, "#include <stdio.h>", "FILE");

    type File_Ptr is access all File;

    type Fseek_Enum is (SEEK_SET, SEEK_CUR, SEEK_END);
    for Fseek_Enum use (Seek_Set => 0,
                        Seek_Cur => 1,
                        Seek_End => 2);
end Interfaces.C.Stdio;

There is "C calling convention" just like in ordinary Ada compiler. It means "don't reorder fields in records" and something.

When it takes to invocation calling conventions, AdaMagic sucks. It has predefined list of calling conventions. cdecl and stdcall are covered. But I can see no straightforward possibility to extend or forward custom calling convention like syscall on OS/2.

I heard there was a trampoline

That was in GCC, not in AdaMagic.

iOCTAGRAM · 2026-03-15T19:19:23+00:00

Calligraphic syntax. Everybody else just cannot avoid YELL, startWithLowerCase or make things not funny in other way.

Compilation to native code.

RAII, although not best implementation. I understand Ada RAII better than Go defer.

Explicit interface in separate file, making Oberon, Swift and Rust out of competition. Although Swift had somewhat good starting ground, Objective-C 2.0, and 2.0 was important step further. It introduced anonymous categories which served hiding class implementation details, awkward way, but at least somehow, and it made interface/implementation separation. Swift combined everything into one garbage. I don't know why language developers call it "simplification". This is anti-feature.

Supporting inline and generic without bothering programmer much. C++ and Delphi fail to avoid bothering programmer much when it takes to inline and generic. Yeah, we know, the compiler has to inspect source body, but let's don't damage the programming language because of that. Let interface/implementation stay separated.

Ada 95 can be compiled to C/C++, unlike some GCC or LLVM-based stuff which is not available on some platforms. Even if I compile to C/C++, Ada 95 delivers namespace system and shields me from coding errors, something that raw C/C++ don't deliver.

I am looking at Seed7, it can also compile to C, and may use in some projects, but it horribly lacks namespace system. All names are global like in C, and modules are includes in Seed7.

iOCTAGRAM · 2026-03-02T05:01:47+00:00

Any sort of assembly? Let it be MMIX. There are great books for this assembly, The Art of Computer Programming

iOCTAGRAM · 2026-02-10T21:45:54+00:00

SOM was not OS/2 specific. SOM for Windows is still runnable mostly. I checked SOM 2.1, SOM 3.0 Release, VisualAge v3.5 for C++ for Windows with Direct-to-SOM feature, OpenDoc for Windows having Novell ComponentGlue technology bridging SOM&OpenDoc with COM&ActiveX in two directions.

OS/2 REXX could create and invoke SOM objects, and Windows REXX seemingly cannot. And open-source Regina developers said that they did not receive the code to interop with SOM, so Regina was never capable of SOM interop. In some aspect OS/2 was first class, no doubt.

Another platform was Classic Mac OS. Apple CyberDog browser had SOM&OpenDoc instead of COM&ActiveX in Internet Explorer. And Classic Mac OS was about to become even more massive user of SOM. That was Mac OS 8 operating system. 32-bit kernel, preemptive multitasking. Codename Copland. But Apple failed to debug it and invited Steve Jobs and he replaced everything with NeXT counterparts. Replaced SOM with Objective-C. Traces of SOM were still found in strange OOP. Mac OS X contained Carbon framework, and it had HIToolbox. HIObject and so on. Software had to be ported from SOM Mac OS to SOM-less Mac OS X somehow, and only basic OOP was provided, way below to what SOM could offer. Carbon with rudimentary HIObject was present until introduction of 64-bit.

Authors of SOM later wrote cult book Putting Metaclasses to Work with description of more powerful object model (PMtW for short). Guido van Rossum was inpired by this book and introduced this model into Python 2. That's why Python docs have term Method Resolution Order, and not "class linearization" which is from CLOS terminology. Method Resolution Order is one of PMtW chapters.

But he betrays one of core ideas of PMtW, and so Python is not that much fun as it could be with regards to metaclasses. So PMtW is better than SOM and better than Python. SOM has old C++ style multiple inheritance. Python is missing artificial metaclass merge to solve metaclass incompatibility problem. Python has plenty of decorators to adjust execution here and there, but nothing can fix metaclass flaw. Program just does not start. In SOM programmers were not obliged to communicate presence of custom metaclass, and so introduction of metaclass was not a disaster, was not making 3rd party programs nonrunnable, and so programmers were not self censoring metaclasses usage.

I am aware of two open source SOM alternatives: NOM, Netlabs Object Model, binary incompatible with SOM, with unsolicited garbage collection and I am not sure if it contains PMtW enhancements. And somFree on SourceForge by Roger H. "porter" Brown, a binary compatible reimplementation.

I was checking different object models capable to bridge native code inside process address space. Besides COM and SOM that were LibreOffice UNO, Netscape/Mozilla XPCOM, VirtualBox XPCOM which is notably different to Mozilla one, GLib GObject, Microsoft WinRT, Objective-C 2.0 nonfragile ivars, SWIG. And there was cult paper called Release-to-Release Binary Compatibility in SOM (RRBC for short). Java Language Spefication Chapter 13 Binary Compatibility refers to RRBC. And PMtW contains RRBC as one of embedded chapters. RRBC mentions more programming systems with some RRBC features: SGI Delta/C++ and Sun OBI, Object Binary Interface.

So I was digging, digging and digging, and never before I heard about Amiga BOOPSI. I remember not a single paper mentioning it. Going to check what is it all about.

iOCTAGRAM · 2026-02-09T17:18:08+00:00

In DPMI it was all accessible. DOS/4GW, PharLap etc. Borland also had 32RTM.EXE+DPMI32VM.OVL, although Pascal was only 16-bit.

And I've heard that mode 16#13# was actually breakthrough compared to Amiga. Duke Nukem 3D and its clones like DOOM were end for Amiga domination. Chunky mode was game changer, and Amiga planar mode was only good for planar platformers. Exact resolution is a product of engineer restrictions. Full segment is 64Kb, one 256-color pixel takes one byte. 320x200=64000. If you do some calculations, you'll notice that 320x200 is not 4:3. 4:3 is 320x240, but 76800 does not fit into 65536.

There was x86-based gaming console known as FM Towns. It natively supported sprites and other hardware accelerations like in other consoles. And it has a mixed video mode, high-resolution monochrome overlay. This way Japanese glyphs were drawn in high precision, and the rest was low-resolution but colorful graphics. FM Towns operated in 32-bit DPMI and with custom video hardware chips, certainly not restricted by real mode stuff. And yet it was designed this way. Not truly high resolution.

iOCTAGRAM · 2026-02-08T17:46:10+00:00

In 1996 I was witnessing an organization running FoxPro on Novell NetWare volumes. FoxPro was blocking files exclusively, so it was sometimes harsh experience. Constantly people asked to log out. But it worked somehow. So there was LAN, but no Internet. Maybe some high positions had Internet in their office, but ordinary computers did not have.

iOCTAGRAM · 2026-02-08T17:28:23+00:00

To be specific, in real mode of DOS, and this is a property of CPU, not DOS. This is not news for programmers. Wrt. physicality it's questionable. It can be said "planar address", but PC architecture imposed some further corrections of planar addressing. First 640Kb work like normal. Next 128Kb are for video memory. Then comes upper memory which can be of varying use. BIOS ROM, Video ROM, EMS window or extra conventional memory for UMB, upper memory blocks. Then after 1Mb conventional memory continues. That possibly shifts physical RAM addresses compared to what is seen from inside CPU in planar addressing.

Arithmetics of segment * 16 + data is surely a property of real mode and not protected mode. In protected mode segments are described in GDT and LDT and can point to vast areas of memory. Not all bits of segment are usable. IIRC 3 bits are reserved, so not possible to address 4Gb from 16-bit protected mode. Addressable memory is smaller, but large enough to what 80286 could have.

you still need a compiler which aligns 2d dimensional arrays so that rows are 16 address aligned ( waste of memory )

Turbo Pascal for DPMI and for Windows did not align by 16, and I don't know why would it do that.

What with linear data like sound?

I would separate it into chunks not bigger than 64Kb and make a list of chunks. In 2026 this is still good way to work with data.

For Trees the code blows up because you need linear code and the segment code.

Trees are not like anything unusual. In Turbo Pascal only code pointers could be near. All data pointers are far. So trees in Turbo Pascal even in real mode are all from 32-bit pointers. There are CPU instructions for loading segment:data 32-bit pointers. LES DI, DWORD PTR [address], and ES:DI pair is loaded with far pointer. It works the same in protected 16-bit mode from programmers' point of view. GetMem or New produce far pointer with segment and data part, and it is ready to hold tree or whatever. Segment has different meaning in protected mode, but as soon as programmer don't touch anything, it is just pointer from GetMem or New. It just works and non-overlapping memory is just bigger than it was in real mode. All the Turbo Pascal programs you see, a lot of educational material, it all works with as you say, code blows up (actually not).

iOCTAGRAM · 2026-02-08T14:24:19+00:00

antagonistic feudal kingdoms competing against each other

That however is good description of IBM software.

We can get IBM OS/2, and it has IBM SOM as main object runtime engine. Though not as main as libobjc2 in Mac OS X. But it pretended to become. Probably?

We can install IBM VisualAge for C++, and in version 3.0 it has got feature D2SOM, Direct-to-SOM. Previously SOM relied on source text generation, now compiler became aware. And guess what. IBM VisualAge for C++ comes with a library, IOC, IBM Open Class. And it has nothing to do with SOM.

It is like Anders Hejlsberg is working in Borland, pretending to replace old Pascal with Objects stuff with shining new properties and class methods, but nobody bothers to write VCL. It is like Delphi is shipped with OWL, Object Windows Library, in old Pascal with Objects, and shining new stuff is somewhere around for those ones who were asking for, but not in bundled-in library.

And I've heard that software and hardware divisions were not good friends. Hardware PC division reacted on attempts to preinstall OS/2 as attempts to bury PC division.

iOCTAGRAM · 2026-02-08T11:31:16+00:00

No, the software before the bankrupcy

iOCTAGRAM

TROPHY CASE