Let's assume you're an OS development team leader. What would be the most important features of your new OS?

It isn't Unix and steals every feature I like from Multics and Lisp machines even if they don't fit together.
The other day I was sitting in my office and some damned kids were talking about this newfangled "eunicks" system. What shit. In my day we had Multics and it worked, there was nothing wrong with it. Damn right. I give the weenies in MY classa C- or D every time they ask why we're usingPL/I. Fuck them, I paid good money for thecompiler. The brats don't know how good theyhave it.

formally specify every part

...

Application isolation.

No automatic connections/updates/botnet. An application firewall.

Needs to be small and tight, like ColorForth. Needs to be able to run well on old and/or non-botnet hardware (like say, a 68030).

Attempt to reunite the differences in escape characters with the web, command line, filenames, databases.

Like, who on earth thought it was a good idea to make the "Enter" key both an escape character, interpreted character AND a regular char. I do understand the reasoning behind each at the time but hindsight is 20/20

This would be the second feature. Why does no OS go all the way?

Formal verification of security.

Pretty sure HPC clustering technologies already do this (at the hypervisor and kernel level).

CoC

Linux and OpenBSD already have that.

That's a property of the character set, not of the OS.

EROTIC Games

performance in games

If performance is your end goal, you might as well throw most security concerns.
t. Intel

I'm sure to be in the minority, but MacOS8/Windows95/XFCE level GUI is all I will ever need. Security and stability are at the top of the list for me. Make it easy to encrypt everything from the hard drive to network traffic. Have an easy way to do system backups. If you're going to add user programs, keep it simple. I don't want fucking cloud support (period) for a simple text editor. Ask yourself, will people even use these programs? Are they to benefit the user, or to benefit my employer? If it's the latter, into the trash it goes. Be sure to give the user full control of every part of the OS. If someone uninstalls a program, and the program returns after a system update, somebody needs to be fired. This should be obvious, but make it multi user. I want to be able to remotely log in and do everything over terminal. I don't want to waste bandwidth on a god damn GUI. Don't let this part be an afterthought.

The OS should be limited to a small range of hardware. Even if it's running on ARM or x86 and could work on off the shelf hardware or in a VM, that other stuff should be listed as unsupported. Official support should never cover more than 20 or so hardware configurations at once, and not more than one or two different CPU architectures. All or most of the firmware in the supported devices should be tailored to the OS so that stuff like power management works flawlessly out of the box and specific GPUs can have full support for things like a graphical front end or setup utility for the boot firmware instead of shit that looks like MS-DOS.

It would need a full microkernel. If it's done right from scratch it could be made so that very little is actually running in kernel space. The nature of microkernels would make debugging a little harder, though I think that's a fair trade-off for fine grain modularity and all the potential security benefits that come with it.

I like ZFS. I think that would be good enough to start with.

I'd go for mksh as the default shell. It's reliable, great for scripting, and fast. Outside of the shell I would also want a rich set of command line tools that don't suck. Simple ncurses tools for stuff like networking, disk management, updating/installing software, and other tasks should be the norm.

A lot of POSIX cancer should be left out. I like the Plan9 approach to things: keep all the good stuff and chuck the rest.

The thing is gonna need a GUI. Maybe not on servers or embedded devices but if I were to design a whole new OS, I want the thing to be used on workstations, too. If anything the desktop version could act as an easy to use development environment for the OS as a whole. I would want the GUI toolkit/APIs to be finished at some point, and not have some constantly evolving ball of shit like GTK and Qt whatever the fuck Apple and Microsoft are using nowadays.

I needs a compiler written from scratch, or maybe forked from TCC. The OS, GUI and all programs should be written in C, which should be the only officially supported language for the platform. This scares away all the bugman numale koders who would otherwise flood the platform with inferior soyware. There should be an IDE for the platform but it should be extremely basic. None of that web browser in a text editor type of bullshit.

Trannies, feminists, and jews aren't allowed to contribute to or use the platform in any capacity.

Facial/speech recognition to keep niggers out

Security over everything.
Capability-based permissions.
ASLR errywhere
Sandboxing out the ass
NX
DEP
Mandatory access control enabled by default (see: Linux kernel security modules)
Package manager
Good license and community-centered open source development
No scope creep -- if a module only does one thing, it won't have 10 other features added in a new update
Modularity a la minix so that you don't have to increase your attack surface unnecessarily by having lots of Built-in things that you'll never need
Effective logging and monitoring tools built-in
Secure by default, not putting the onus on the user
Good documentation
No sideloading allowed -- an OS is only as secure as the software installed on it
Good firewall ACEs by default
No SSH, no ability to create reverse shells, such as on linux with bash and /dev/tcp/
Built-in engine for malware and hacking IOCs that combines software updates with security scans
Heuristic analysis and basically the OS treating every process and file as a potential attack vector that needs to be monitored and kept in check
Windows UAC-esque thing for networking (sort of like UAC + macOS LittleSnitch)
Easy way to monitor network traffic, like a built-in Wireshark, but made more user-friendly for dummies
Forced disk encryption
TOTP multi-factor authentication even for local logins, including su/sudo (or whatever the equivalent will be called in this OS)
gnu coreutils/moreutils but redesigned with security as the highest priority
Written in security-focused languages like Rust as opposed to C/C++
Shell prevents user from using harmful/destructive/insecure commands (something like a reverse shell or bind shell or sudo rm -rf / --no-preserve-root would simply not be allowed to run)
Walled garden approach as opposed to "muh freedums"
None of the fragmentation problems of Linux, where there are zillions of distros and tons of devices that never receive updates
LTS type releases where the only updates are security updates, and feature updates are only rolled out every now and then
Only supports non-harmful hardware
Features and performance are secondary to security. If a new cool feature adds security problems, it won't be added to the OS.

Bio security is weakness and a scam.

How would you recommend preventing niggers from logging in, then?

modularity, security, robustness. would probably use a microkernel, since i am not too focused on speed but rather on crash resistance.

i would probably use a decentralized IPC system where there can be multiple queued instances of tunnels. something like dbus, but much simpler and without being a shitshow with unneeded shit like remote seats. perhaps it could even replace UNIX pipes although they would probably be used for piping.

i would focus on unix philosophy, although i would provide complexity where needed.

i would have multiple character/devices into devfs folders such as
/dev/sd0/0.

my components would be reusable and easy to refactor, so i.e. i could use let's say the init system in another os.

i would not make pocket knife components like systemd.

webcam detects nigger
alarm sounds "JAMAL GIVE IT BACK, JAMAL GIVE IT BACK..."

Using a good password and changing it often.

just make the login UI in cursive. in the documentation use the term "child process" as much as possible and make extensive use of master-slave metaphors.

Attached: dog_head_rest.gif (353x200, 3.98M)

No password, just a simple equation to solve. 99% of niggers won't know what a derivative is.

biometric authentication is dumb because that means you have a password that can never be changed (can't change your fingerprints)
what will you do in the event of a data breach?

The biometric is used to encrypt your key, it's a simple concept called wrapped keys. In this scheme, you can change B any time you need to, and it won't even necessitate re-encrypting your data.
A:bio -> B:custom_set_key(can change) -> C:n-bit random number

Free software. And use hurd kernel just so that noone can call it Linux.

github.com/froggey/Mezzano

You and your 30-year-old mailing lists can go fuck off now.

Attached: db663542a5647dab7c1cc079089028744a5b9767010c6e8773a05e7a2bfcb0fd.jpg (655x1026, 196.94K)

Being able to talk to God.

Like a modern lisp machine
But written in rust
And it runs on the blockchain

Thin enough to contain TCP/IP stack and a python interpreter. Call it OS4IoT, you'll be the next billionaire. Don't worry so much about security now, innovate fast, patch later.

it's called linux, my guy

I have seventeen million dollars I want to invest in your project right now. I firmly believe that this is the future.

You're too late
hal.inria.fr/hal-00781769/file/2013-os4iot-final.pdf

I would basically recreate Midori.
en.wikipedia.org/wiki/Midori_(operating_system)
joeduffyblog.com/2015/11/03/blogging-about-midori/

Isn't Singularity just an implementation of Midori? You could download Singularity and build on it

I'm no coder but I know what I want from an user interface: it should look and feel similar to the classic Mac, because they got a lot of things so right on it, and some of these lessons have been forgotten:

More pics: guidebookgallery.org/screenshots

Attached: rhapsodydr2.png (640x480 77.15 KB, 32.52K)

KDE, MATE and Unity 7/8 (both maintained by the community now) do it. There's also several projects to make it available for other DEs including XFCE and LXQT. If only GNOME devs weren't such morons they'd include it too. Though there is a GNOME extension for that. It barely works.
What's wrong with the dock they're using now? It's easier to see what's running with a glance.
Unlike Windows and early KDE and GNOME, the Mac guys realized that adding too many 3D elements and shadows would make it ugly. Those screenshots look good even today.
XFCE has similar themes included by default.
Not too big of a fan of this myself.
This already exists (except on GNOME, of course) on the form of icons on the task bar.

Those fuckers stole my name and went back in time!

kek

consolefag detected.
if you can only support a small amount of fixed hardware setups your code is shit.

Why do you want DOS back, user?

I'm not a consolefag. I'm a fan of SGI MIPS and HP PA-RISC workstations. Not that an uncultured street shitter like yourself would know anything about such glorious professional high end Unix systems. Go play with your Loonux and NT toddler toys, kiddo.

...

A sane and sensible integrated scripting language with tooling to maximize the potential of the OS out of the box

Attached: 3636635-windows-98-wallpapers.jpg (800x600, 50.31K)

What do you mean by this? Lisp? Python? Lua?

A derivative of an existing language in terms of syntax, yes. Add the ubiquity and immediacy of bash along with an extensive and robust standard library and that's what I would like to have.

Hardware acceleration is for pussies. Real men use an ET6000 or S3 Virge.

Attached: 1542690184.png (800x600 1.02 MB, 530.44K)

This has been hard on Windows

what game?

So, a rich consolefag.

The majority of those issues have been due to the fact that Windows originally had two versions that were completely different under the hood and only semi-compatible with each other being developed in parallel. Things are a lot easier when you don't assume no one will need multitasking or more than 640k of ram, and don't have build your graphical OS around that using dirty hacks. That's the whole reason NT was created in the first place.

Unreal, and Unreal Tournament 2004.

An operating system based off the Commodore 64. Thats 64bit and Command line is C.

You don't know what you're talking about.

why?

Attached: an unsettling discovery.webm (1920x1080, 609.78K)

No, they just threw the menu bar from the program window into the task bar which is retarded because it means that you have to select the the other window first so that you can click its menu bar item instead of just clicking on the menu bar item in the window it belongs to.

1) Input resources are supplied via a pointer that is handed to the software by the OS. For instance, reading keyboard input is done by a loop that reads from a *char and similar interfaces for output.; for instance, each application is handed a matrix that it can draw pixels to. This matrix is simply a representation of its window.
2) Virtual hardware layer. Everything from GPU CUs to x86 cores is treated as a virtual core that can be used for any purpose, general purpose computing, drawing graphics, communicating with hardware devices. It's all managed by the world's most over-engineered scheduler. This would also allow arbitrary scaling across multiple systems, since virtual resources could be shared overr the network.
3) All software written by competent programmers. Any Indian caught within 200 meters of development HQ is shot dead on sight.

Retractable cupholder support

font rendering done in kernel space.
filesystem case insensitivity.
privilege escalation.

Fucking macfags

This is your mind on UNIX.
How's that teletype holding up for you?

Yup, they really love Fisher Price.

You can't be this fucking retarded

the next OS will have a team of 1 and you will be able to write a compatible implementation yourself
-single memory-safe PL which is trivial to implement
-language identifiers are UUIDs with cryptographic hashes (so for example you can know the same guy wrote these 400 functions)
-characters are basically bitmaps but efficient and with extra metadata allowing stuff like collation and searching. stuff like the PL the OS is implemented in doesn't even use text, so the characters don't need to be formal at all
-performance is not a priority, but it will easily beat any modern Linux system even with a memory-safe PL since there's no bloat

least important. you should be able to boostrap the OS yourself. writing a VESA driver is trivial, HDD and network shouldn't be much harder

Inferno ( vitanuova.com/inferno/ ) already does this. DF BSD's HAMMER2 filesystem also half-way implements this.

Mac logic

literacy tests

Capability-based
Microkernel
Has a scope such that it can actually be called "done" (new releases change the set of supported hardware only)
Comes with development tools

EAL 7

Written entirely in Ada.

I don't see a point to this if you have verified that you can't smash the stack.

The code must be limited to 1000 lines and be developed in full not niggerlicous programing language.
It must work within the limit of 640x480 resolution and must allow for low level (ring -3) capabilites, everything should run in ring -3.
Simply because everything will be ring -3 this allows for more robust modifycations of the system in a way i could discribe as a "programmer's playground" where you aren't limited by the pre imposed limitations of sys admins and proprietary devs.
The way modern linux and unix systems work is tied to the way an old 1970s mainframe would, the problem with that is it doesn't work as a consumer grade system, it simply has too much useless crap for the type of person who wants use it.
The idea of this system would be to give the tools rather then the solution, it's a great basis for people to play around with the way the system works instead of having to read shit ton of manuals to figure out some over the rop command that you'll never actually need more then once.

It should work completely on the cpu, GPUs were a mistake, a small hack around for the nigger fucking console crowd, people who were never really intrested in the computer but wants to be distracted with useless shit.
This should not be seen as a limitation, but a solution.

The overall design is ment for the user developer, third party developers are shit ape nigger fuckers.
Ever seen those "scene" videos, that is real shit. In a user developer system it incourages the user to experiment with the system to find solutions for the "problems" that arise with what many consider to be "limitations", this gives rise to the greatest feats in code.

I thought Terry died...

Entirely visual interphase, no text menus only icons, entire UI whould be like a mind map, click from node to node to reach a file.

Attached: 25bc1167bd479f494ec0a8cf1e13cd16b3af7cee6de21ed9e3811015d7fb3798.jpg (255x250, 18.74K)

A job is a form of slavery if your only """choices""" are to either starve or have a job.
There's no "consent" in anything in which you are forced or coerced to do.

Taking action is slavery because not taking action will result in death.
after a certain point you just have to take responsibility for your life on a personal level

...

Ease of use.
I don't want a userbase consisting exclusively of autists.

Attached: forty keks.gif (716x620, 728.96K)

Customizability with built in tools to shape it as you like it.
Easy integration of addons and skins and whatnot on top of the base structure.
Hierarchically structured, with the ability to shut off parts or layers of the system when they are not needed such as GUI or unnecessary advanced options in menu's. You should be able to switch it to any kind of customizable mode like server mode or fancy mode or work mode, and it would add and deactivate the needed or unecessary layers so you and your computer can focus on what you are doing.

GUI is fully integrated like most sane OS, and an API that is stable with a focus on not adding new shit and breaking old programs.
Easy per-process permissions and fine-grained networking control. Think umatrix at the OS level.
A Windows compatibility layer like wine, supported even on non-x86 architectures at the expense of performance via qemu.
A Linux or *BSD driver compatibility layer for better hardware support (and maybe a Windows one, but Windows drivers a shit and surely even hardcore Windowsfags would be able to see that).
Standard bash shell that can be replaced by some alternative if the user really wants to.
Package management system that's not read-only (so friendly to user modifications without recreating the whole package as a custom package) and has the ability to download&backup/install archive-quality packages (Windows-style, statically linked so you won't need to worry about dependencies and incompatibilities later on) for those that want the option.
MIME types and file extensions can be configured via a GUI if you want.
A file manager at least on par with Windows 7, more customizable like nemo and Dolphin's lovechild, with support for mounting images of many different formats.
A simple image viewer that is integrated with the file manager, so sorting a folder in the file manager is also reflected automatically in the image viewer.
As robust recovery from desktop environment crashes as Windows (running task manager to start a new instance of explorer to get your desktop back vs having to ctrl alt f1, log in, kill processes, possibly even do some session shenanigans).

Pretty sure people would eat that shit up and leave Windows altogether. Haiku looks the best of any alternative OS so far with its design decisions, but I think a fork of ReactOS could go farther in theory (in a world where it could actually leave alpha). Hoping more people contribute to Haiku though.

depends on the market (servers or casuals?). I'll answer only for casual, home users:

like risc-v, or something licensed better. I agree with this guy about hardware and maybe kernel

break compatibility, fuck em

we are not running mainframes with 100 users anymore

xkcd.com/1200/ , I think the only thing that should need permissions are web related. for everything else it's just annoying. maybe plan9 is better at this stuff, since they originally planned a distributed model of computation, so only the network connected device would need permissions and browsers would only write to a dedicated network machine.. kind of leads into this , but sandboxing all network connected process might simplify things for single user PCs (like templeOS).

don't let these run away, the only thing that abstractions can't fix are too many abstractions. imo gnu/linux is too far gone, but it had to be for linux kernel to work with so many diff drivers. also this . the less abstractions the better, to an extent. cater to programmrs, not normies here - the users should be expected to learn the computer, but don't make it ridiculous.

like this

grow some balls

top priority, most important thing here. see lisp machines, emacs and templeOS. have great documentation, introspection, extensability, debugging, solid suite of tools made for composing larger programs (unix style). shell is also a REPL

yeah basically this

Attached: temple.jpg (200x150, 4.65K)

all javascript

Use toe prints. Most people are too retarded to think of using them as backups.

Don’t need compatibility layer.
Linux has FUSE, Windows has WinFSP.

Not sure what is the point of microkernel meme when everything is a web app in a sandboxed browser with a supervisor process.

The advantage of monolithic and hybrid kernels would be gone if the MMU was several times more complex to allow for more granular permissions (or at least save on the kernel vs user mode task switching).

A new OS is not necessary.

It is all terrible.

Apologies, I forgot to say use FUSE or WinFSP with a virtual machine.