Out of all mainframe OSes, VM is the most approachable imo, as long as you grasp minidisks and how s390 device addressing works, it becomes just a somewhat clunky DOS. I would also suggest checking out the 2.4 VM ADCD, it is a package with basically all the interesting software, and it is out there if you look for it.

> a somewhat clunky DOS

And the Community Edition even has a handy DIR command for you.

This document has a lot of things left to add - the machines can really be a lot more interesting. So far, I haven't figured out how to connect my real printer over the network, the other machine with shared disks but no OS, and even creating a new VM for our user. I also know there are a lot of other interesting things on the base CE image that can be super cool to show a newcomer.

It is a very cool operating system. I had the pleasure of configuring it (in it’s ibm z/VM form) from scratch a few years ago. However due to company politics it only ran for 2 years. If you are based anywhere in the US you could probably make a career out of it. If you are in Europe I don’t know if it is a wise choice. Not much z/VM there. If you now own a modern mainframe and want to run Linux workload for example I think you are better of using kvm. However if you need to run z/OS virtualised your only option is still z/VM

I have recently played with a plain VM/370 R6 and it's very bare compared to CE - not even bold in the terminal to highlight your current line in EDIT. I was thinking of adding it to my collection of Docker images, but I need to play with tape images and, perhaps, load a bunch of them into the container image so there is something to do with it that resembles modern computing.

> not even bold in the terminal to highlight your current line in EDIT

CMS EDIT was designed when the 3277 was the standard terminal. Those things had a SYSTEM AVALIABLE indicator on the center of the right side of the screen, outside the text area. That was the current-libe marker! When the 3278 came out, all the indicators moved to before the text area, but by then, everyone had moved to EDGAR or XEDIT.

I'm guessing neither EDGAR and XEDIT fall into the friendly license of VM/370...

They do not. That's why we have EE.

You probably could make a career out of it in the US, but it would take a lot of luck. I see mainframe jobs come up every once in a while--they want a ton of experiences, specifically with mainframes and preferably in their industry. I always thought it would be kind of cool but I have no idea how one would break into it.

Generally speaking, students break into it via ISV (independent software vendors, the big ones in this space are IBM and Broadcom but there are many others) apprenticeship and training programs, before getting deployed on site (or staying at the software vendor if you are very good or they have need of somebody junior for a position).

The extreme experience requirements are generally exaggerations. They only happen to exist because there are people who really do have those many years in this field. But I've gotten jobs (I'm a systems programmer, many hats style, z/OS and Linux and C and JCL and Shell and REXX etc) and I've gotten jobs before from these sorts of excessive experience postings before despite me being fairly new to the field (just reaching senior level, about 5 years experience in my subdiscipline, which is systems programming, as opposed to applications programming or security, two other primary specializations for people with CS degrees, there is also operations and IT work available for mainframes but probably the pay rate would be of no interest to somebody on HackerNews).

So many ancient weird rituals to use this thing. We've come a long way.

Believe it or not this operating system is very much alive and kicking in the form of z/VM 7.5 and some of those ancient rituals are still considered normal in that world ;)

Weird? Let's talk about the Unix userspace commands!

So much here:

Notice in EE the use of [F3] to exit as in the original CUA. As I said at https://news.ycombinator.com/item?id=50026580 .

Unix called it 'text' too. That's why the ETXTBUSY error's traditional message string is "Text file busy".

It's not losing the first character from FORMAT because of some magic line printer discard for the first character. It's losing the first character because you don't understand FORTRAN. FORMAT, as you can see in that example program, uses field descriptors to describe formats. It's losing the 'H' from 'HELLO' because that character means a 'Hollerith string' follows it, which in your case is the Mockney 'ELLO WORLD'. (-: You need an extra 'H', to start with.

In Unix terms, this is akin to the classic mistake of using printf() instead of puts() for your Hello program, and using a percent character in your string. In BASIC terms, this is PRINT USING, not PRINT. And yes, that does mean that technically you are holding it wrong. The text to write should be in the list given to WRITE, and FORMAT should just be specifying the field descriptor.

Only then do you get to the fact that the first column of formatted output specifies the number of printer lines to advance. So you are holding it doubly wrong. There should be a space after the 'H' denoting your Hollerith string that precedes the 'H' of your 'Hello'. (-: Notice that IBM's program has a space between the field separator "14H" (14 character Hollerith string) and "PROGRAM ERROR" (13 character string). That's not just random whitespace. It's the first character of the string, it means 1 line of vertical space, and the string is actually " PROGRAM ERROR".

You can get several native versions of REXX for Linux-based operating systems and the BSDs, including ObjectREXX and Regina.

* https://pkgsrc.se/lang/rexx-regina

* https://pkgsrc.se/lang/oorexx

* https://pkgsrc.se/lang/rexx-imc

It's 2026, and I just wrote about FORTRAN 66. Good heavens!

> It's 2026, and I just wrote about FORTRAN 66. Good heavens!

Thank you for the clarifications. I'll dig a little more and add that to the article. I learned Fortran 77 a long time ago, but I never used Fortran 66.

To learn more about the mystery first character, the search term is “Fortran carriage control”. I’m not sure all the choices were ever standardized, but you can typically use + (don’t advance the carriage; i.e., overprint the last line), 0 (double space), or 1 (“form feed” to the next page).

I can remember my Fortran teacher illustrating these with little hand gestures as if he was holding the knob on a typewriter carriage.

I also remember someone at college who had a grudge against the computer minions behind the glass who took your printout and filed it in a cubbyhole for you to pick up. He would run a job to repeatedly print

+________ (…132 total underscores)

which had the effect of cutting the paper, which would drop out of the bottom of the printer so the minions had to open up the printer and refeed the paper.

They were. See §7.1.3.4 ('Printing of formatted records') in the 1966 standard. I went and double checked before posting, because I am supposedly not the FORTRAN person in my family. (-:

It's been over 40 years since I had to type #CP IPL CMS PARM AUTOCR

Then engineering got a VAX and everything moved to VMS.

Yes. Everything is profoundly alien to anyone who's coming from a Unix background I was initially extremely confused. I was asking myself how does VM/370 define and starts VMs and thinking of a command line tool to do it.

Thanks for this, can't wait to try it out. I discovered the Hercules emulator a while back, downloaded everything and fired it up, then discovered I had literally no idea how to do anything. It's just such a different world than the ones I'm familiar with.

Indeed, it seemed to me, back in the 1980s, that schools almost consciously refused to teach anything about IBM mainframes. My junior college had a 4331 and a Prime 650; the 4331 was used for school administration purposes and the 650 was used for coursework, and never the twain met. Networking was in its infancy and basically didn't exist on-campus, with all terminals hardwired. When I got to UIUC, almost anything interesting was being done on either on UNIX or on CDC mainframes (or the Cray that I saw but never used).

A guide like this is quite handy for an old hand at computers who finds mainframes completely alien. It's even odder that this old version of VM was open, and yet that never really gained much traction outside of diehards keeping the flame alive. I wonder what the computing world would look like today if VM had been put under a copyleft license? I also wonder if an XT/370 could run this thing natively, or if the 370 side was too slow/lacking needed features.

It it me, or does it feel totally different to be logged on instead of logged in?

Yes. But it's also you

Long time no see!

"Turn on, boot up, jack in!" -Timothy Leary

https://en.wikipedia.org/wiki/Turn_on,_tune_in,_drop_out#His...

This is why I post weird things. Bringing cool people together is my real hobby.

I'm not saying that old IBM mainframes should be our inspiration for future systems. But I'm very happy to see the interest in non-Unix-derived operating systems.

Indeed. It's refreshing to see something that's not a Unix or a bastard child of VMS (even VMS is quite different from a Windows command line)

PowerShell brings some of it back! Though I do not think VMS had PowerShell (and Nushell)'s best feature; being able to pipe objects between commands, and not just text strings.

Having played with OpenVMS for a bit and suffering some of the steep learning curve, I'm not sure bringing forward more of the VMS heritage in Windows is the Right Thing To Do.

I think they should be. Top to bottom hardware and software co-design. I wish they hadn't gone object code only, because I feel like that really ended up causing a lessening of cool software coming out and a too heavy focus on vendor software (back in the old days, the systems programmers at customer shops often modified the operating system and would get those mods put into the OS by IBM for next release, now the sysprogs still modify the OS, but much less likely to be codesigned with IBM if you come up with something cool, and there is less visibility into the source for the OS kernel for z/OS).

But still, the hardware/software co-design and full system suite provided (FreeBSD style) kernel + OS attached really is a great way of doing things and the more I work in Mainframe and also work on Linux, the more I wish Linux vendors took more cues from the Mainframe or FreeBSD worlds.

I suppose you could argue that Oxide Computer is attempting this as we speak. One of the reasons I am a big fan of them.

All that and the fairly incredible amount of engineering that goes into the whole architecture, from processor, to memory system, to the numerous hardware assists. And build quality, because the machines are tested to work through earthquakes.

I wish hackernews could see more articles like this, and escape a little bit from the amazing unix world.

If you can think of other fun things to do on a VM/370, and help me figure out how to do them, just let me know. I'll be more than happy.

I was a mainframe engineer at IBM back in the day (our actual label then was CSR, which some people derisively interpreted as Card Swapping Repairman - which was very far from the truth).

One of the software guys introduced me to VM. Once I got my head around that, he demonstrated running VM itself - within a VM. My head exploded.

Yeah, they would try to how many levels of VM you could run before it slowed down too much to be usable. About 4 or 5 levels back then.

In VM development, we would run the version of VM being developed as a guest and if you wanted to test its guest emulation, you had to run a guest under it. When I had to do this once, I didn't want to deal with the complexity of creating a mainframe os guest like MVS, so I would run CMS as a guest. I would define an extra virtual CPU, which CMS would know nothing about of course, and SIGP (signal processor) it to run code fragments that I wanted to run on a multiprocessor guest.

When you are emulating guest stuff, VM's view of things is completely different than what the guest thinks it is seeing. So of course most new hardware features have to be virtualized if they are to be used by guests and this means recursive VM's as well. So technical discussions could be something else if there were a lot of context ans POV switching going on.

There were several obstacles for me to understand this:

1. Press Return before logging in. Simple to remember, but if you don't, you get...nothing after typing LOGON CMSUSER.

2. Use model 3278-4 (which is 80 columns by 43 rows) otherwise you get mystery blank screens.

3. There is no autoscroll. After 60 seconds it will timeout and scroll another screenful. Otherwise press PA2 for the next screenful (useful for lengthy LIST commands.) To interrupt very long output, type HT to halt text. NOTE: PA2 not PF2. See "MORE..." at bottom right indicating there is more text to scroll.

4. The CLI is an overlay mount of CP and CMS. If CMS doesn't recognize a command, it gives it to CP to process. Compare Q DISK and Q DASD, the Q DISK result it from CMS, the Q DASD result is from CP.

5. Use LIST (ISODATE) for more details and modify dates. Abbreviate as L (ISO.

6. Redirect Fortran unit 6 to the terminal with FILEDEF 6 TERMINAL (BLKSIZE 133) and you may be unsurprised to learn this took me three days of searching to find. Now your LOAD HELLO (START will produce output on your screen, not a file.

7. There is GCC with two available runtimes; BISON, DIFF, DIFF3, as well as PL/I, PL/360, Pascal and WATFIV for those old enough to remember the Waterloo Fortran compiler which had actual usable error messages. MINIZIP is there too. No APL, unfortunately.

8. I never did manage to get Hercules to exchange files via the Punch or Printer logical units. So, no file exchange at all. If there is a way to get ascii files or binary files in or out that would be helpful.

9. The 3270 terminal display is programmed with special character pairs indicating fixed text, text fields changeable, double-wide text, etc. So far I haven't found a way for a C or Fortran program to send and receive text from the terminal that can completely control the screen and read back the contents. (A program running under CMS of course.)

> and you may be unsurprised to learn this took me three days of searching to find.

I am not surprised at all. This page is more or less the total achievement of a couple years of playing with the system.

> If there is a way to get ascii files or binary files in or out that would be helpful.

There is $INDFILE, which, IIRC, is something from the PC/370 era. The x3278 terminal uses it for its send/receive file facility. $INDFILE doesn't come with plain VM/370 R6, but is part of CE.

There is as an APL system for VM/370, but IBM's licensing restrictions prevent the VM/370 Community Edition from pre-installing it.

Dammit IBM. And, if we say the H-word in IBM circles, we get banished.

CMS had some neat stuff at the time. Rexx and exec2 supported the subcommand environment. You could write xedit macros in rexx with edit commands instead of system commands.

The mini disk letters were your command search order, like unix path. But internally it was a linked list so you could rearrange the order it you wanted to.

File mode 0 files were supposedly private, you couldn't see them if you accessed the disk read only. But the access command ran from the transient area, so you could load it, no-op the test for char '0', and then execute it to access the file mode 0 files on a read only disk.

Mini disks supported sparse files. So if operations didn't migrate mini disks correctly, you could put a 100 MB file on your 5 MB mini disk (this was the 70's), that would stop them.

There was a diagnose command to read your 3270 terminal screen including the field attribute chars which you could replace with markup tags so you get screenshots for your documentation.

There was a lot of hacking going on in IBM at the time. Just wasn't public. If Peter Capek's VMNewsletters and some of the internal discussion groups were ever published, you would know.

I wrote a Gopher server using CMS Pipelines and Rexx which morphed into a basic HTTP server, ran for years on internal IBM systems (mostly used to serve the internal TOOLSRUN forums to the intranet).

We had IBM's at my University back in the day, got some time in on those for sure. AIX is its own thing, I'm a bit surprised they don't offer a hobbyist version to get a little more mindshare. Nobody chooses it from my experience, it just comes with your IBM, probably plus tip, and you probably use it if you have legacy programs and can't just run Linux. Makes it tougher to get qualified admins though, maybe that's the whole plan. You just hire 'em from IBM.

The biggest problem is AIX (at least these days, not sure of the history) is POWER only. Yeah you can get one for cheap off of ebay (I did :) ) But that's a very niche market. You can find pretty modern AIX downloads on the Internet Archive. Not sure if it's officially sanctioned by IBM, but I really don't care for my own use :)

I appreciate the linked effort post although I'm more into playing with MVS

Two problems:

1) The coolest thing about old / unique / non-standard OS is the features. Yes I get it that noobs need to log in and compile hello world but what turns the experience from an hour of fun into months or years of fun is crazy stuff thats just not present in the modern world like JES2 and ISMF (Well... SMF) and CICS (Well... KICKS) and doing weird things with ISAM (like what if your OS by default had a builtin database as a primitive structure just like how unix has built in text processing?)

I think people get turned off by "well OK I can compile and run FORTRAN just like on my emulated PDP-8 or my emulated Nova so why use, in this case, VM/370?" Well I would assume there are features of VM/370 that are as cool as my favorite MVS but I'm no VM expert. THAT'S that selling point to get people into the hobby. Start out trying to get NJE working on JES2 and next thing you know you're binge watching old MOSHIX videos on youtube while eating popcorn and hearing the annoying background music in your sleep.

2) As per above the biggest problem with old iron is the coolest stuff is not entirely legal even in 2026 so instead of running "real CICS" you get the reimplementation KICKS and no ISMF you get plain old SMF which isn't quite as cool. I mean, SMF is cool, just not as cool as licensed ISMF. See also you get to play with RPF not ISPF/PDF. RPF is cool but someday I'd like to legally run ISPF at home.

In college, we had a CDC Cyber running NOS.

For programming, they taught us enough to use the XEDIT line editor, the Fortran compiler, CATLIST for the directory.

You'd apply these in rote fashion, the goal was to get through your programming class. It wasn't an a OS design or computer architecture class. It was "calculate Easter Sunday in Fortan" class.

Our Fortran (F77) used channels 4 and 5 for console in and out (which could probably be redirected using some command, no doubt. I don't know if it was. NOS thing or some Fortran thing that we used 4 and 5.

But it had these other things that you'd touch on, if you were geeking a bit in the community. Things like Direct Storage using the ATTACH command (whatever that did), PROC files (scripts), PROC file libraries, DAYFILE (basically your job/command history).

I would like to have a deeper understanding about some of those concepts of how that OS worked, design choices they needed to make, etc.

Today, "everything" is UNIX. Or certainly viewed through UNIX glasses. Even Windows is UNIX today.

North Avenue Trade School and Goda? Having done COBOL in high school I couldn't wait to get back to Pascal etc.

I used to work in the computer labs and would regularly have to tell freshmen Fortran students to indent every line one more column.

I want to check my imap email with RDRLIST

Whoever invented Rexx is a god. I wrote a program to renumber and indent Fortran programs in Rexx, and it actually worked. Outstanding documentation; IBM was THE standard for docs back in the '80s.

Mike Cowlishaw. He also created the Java decimal math, and the I EEE DECIMAL floating point.

They are still a standard for Docs, if you look at z/OS docs today, they put all Linux distro and even Kernel docs to shame to be perfectly honest.

Organized PDFs of the order of a thousand pages for literally every subsystem or additional program etc. Over a hundred PDFs in total. Probably 100k+ pages of raw docs.

And that's not even including the Principles of Operations (the mainframe s390x ISA reference).

I work in Mainframes as a Systems Programmer at a software vendor (C, JCL, HLASM, REXX, Shell, a little Python here and there). AMA. My primary operating systems are z/VM, z/OS, and Linux on Z (s390x Linux), typically RHEL.

I've also previously worked as a Systems Programmer at customer shops, and so I have some insight into that as well.

AMA.