Lisp-homos can't do anything with their shit language

>simple text editor

Attached: sagenegated.jpg (600x450, 57.16K)

JOJ

Attached: 1460045804817.png (400x480, 166.37K)

It was also supposed to be one made my LISP users, not one made twenty five years ago.

Attached: sage_negated.jpg (447x306, 19.84K)

...

the graphical requirement was pretty lame, but rather than righteously flout that ("here's a vi-like editor for a terminal that someone might actually grow a practical editor out of, take it and fuck off"), someone posted a Racket solution that was a GUI text buffer editor with no features, not even file management.
Lisp confirmed terrible.
These threads are OK. Just post more code and less of the same sniping you can see someone already posted five times already.
Challenge #0: write an ed-style editor.
required tech:
1. command line args
2. reading/writing files
3. line-based replacement of file contents
4. interactive commands
minimal ed-like commands for those without culture. Feel free to make real ed commands instead:
1. 'p' to print out entire file content
2. '123 r blah blah blah' to replace line 123 with blah blah blah
3. 'w' to write file
4. 'w foo' to write to file foo
5. s/a/b/ to replace a with b in the entire file.
exhibit #0: open a file containing the following text and fix it with an ed session. You know what the problem is. No need to word wrap.Linux was originally developed for personal computers basedon the Intel x86 architecture, but has since been ported tomore platforms than any other operating system.[20] Linux isthe leading operating system on servers and other big ironsystems such as mainframe computers, and the only OS used onTOP500 supercomputers (since November 2017, having graduallyeliminated all competitors).[21][22][23] It is used byaround 2.3 percent of desktop computers.[24][25] TheChromebook, which runs the Linux kernel-based Chrome OS,dominates the US K–12 education market and represents nearly20 percent of sub-$300 notebook sales in the US.[26]Linux also runs on embedded systems, i.e. devices whoseoperating system is typically built into the firmware and ishighly tailored to the system. This includes routers,automation controls, televisions,[27][28] digital videorecorders, video game consoles, and smartwatches.[29] Manysmartphones and tablet computers run Android and other Linuxderivatives.[30] Because of the dominance of Android onsmartphones, Linux has the largest installed base of allgeneral-purpose operating systems.[31]

...

Well, I know LISP can't do much, but that's kind of pathetic...

it's a
new
goal post and it's numbered, so that later challenges can be easily distinguished from it.
meanwhile, "moving goalposts waaah" we've already got 5x the quota of in these threads. By my solemn of goalpost-moving, you are hereby required to complain about goalposts only in the context of a code solution to a numbered challenge, or to the original one.

TOP
FUCKING
WEW
LAD

red flag.
mods?
mods?

...

...

Stop being a newfag but thanks for the bumps :^)

in the last thread someone got btfo when an user actually delivered. the best part is that he is still assblasted about it. also, why haven't you posted any actual criticism of lisp? instead of mindlessly creating new threads, why don't you actually prove that you know something you are talking about. because there could be a genuine (((reason))) why you didn't accept the text editor that user posted. you even seem to think that coding a text editor is an insanely difficult task. could it be that you are just a nocoder yourself? you can prove that you can code by programming a text editor in Rust.

Attached: 1562548851-1.jpg (555x681, 85.83K)

Not technology

...

heh, what kind of pathetic reply is that? you aren't even trying.

Attached: kizuna_sigh.jpg (451x442, 33.19K)

I'm here for technology, not to try to program in rust

It wasn't a double post retard. The first post was deleted due to a typo, then I made a new post without the typo.

>goalpost

Attached: 7fa94a44d73895eb1864.jpg (638x746, 69.42K)

...

Attached: clisp.png (455x326, 88.61K)

cool story bro

>last resort to muh (((jews)))
while it is true that it's important to check who is behind any given project/study/whatever, just saying something about kikes means nothing by itself. seriously, the last thread was going on for a long time, and yet you are still unable to provide any criticism at all. prove it that you actually know something about the subject. also, how does GPL has anything to do with lisp? the fact that you aren't posting anything of substance just proves that you don't even want to discuss anything.

Attached: Kizuna_Ai_God_You_are_Pathetic.jpg (1024x1024, 72.75K)

One was posted that failed to meet most of the requirements and used a pre-made framework. It couldn't even save the text to a file and they didn't compile it to a binary as per requirements. From then on the LISPfag claimed victory and anything pointing out that flaws in his shitty code was called goalpost moving. He even went so far as to slide the old thread off the catalog to hide his shame. Now he replied to every thread accusing everyone of being a LARPer when he couldn't even put together something simple in the dead language he constantly shills. He's the samefag that runs around calling everyone that posts something about *nix brain dead.

I was honestly let down because I wanted to see what he could do. It's no surprised he turned out to be the biggest LARPer of all and all his posts were pure projection. He's only slightly more tolerable than the Rusttrannys.

Attached: bc1bfb85614097b2731364dcb35f81e9e5b0f4475c5f1e9f83b33586ce032b4a.jpg (800x800, 239.45K)

you glow in the dark, pal. your little "challenge" was completed. i remember how you started kvetching because the text editor needed its runtime. but what you failed to realize was that this little comment revealed that you know very little about programming. even C needs its runtime Then whenever the thread was almost got pruned, you necrobumped the thread with more low-effort posts.

Attached: 87585c8dd30197e1fb0c33a1cff056513f6bcd5c5df7c70679e64224f50e179a.png (1584x1584, 2.24M)

If your code was so great then re-post it for all the anons to decide for themselves.
you won't

Lisp is, and will continue to be a toy language for academics and do-nothings. How long has MIT shilled lisp, scheme and racket? How long have those abominations failed to produce useful software? I ask you, if lisp is so powerful, where are the results? Where is the software? Nobody gives a fuck about the intellectual purity of the implementation of your language. Does the software solve my problem or not?

The lisper is immunized against all dangers: one may call him a scoundrel, parasite, swindler, profiteer, it all runs off him like water off a raincoat. But call him a lisper and you will be astonished at how he recoils, how injured he is, how he suddenly shrinks back: “I’ve been found out.”

Why don't you post your criticism of lisp (in general) or the text editor?
ironic.

Attached: a1dd5e2a825b8c112dee26a352e612677a9e08421ec111ea0d46bfef37f2ee2e.gif (230x270, 60.08K)

Zig Forums really needs to stop misusing this quote. Lispers do not fret at being called Lispers.

I'm not the faggot that sperged so hard I became 250+ replies to the original thread. Here are the requirements you failed to meet for reference. Before you claim I was the OP it's a copy of the picture he posted. I should go dig up the archived version of the thread for a good laugh. You were so butthurt you constantly came back to sperg any time someone bumped it. Stick to calling anons LARPers and posting 30 year old posts from mailing lists shitting on *nix. That's all you're good for.

Attached: lispfagscantcode.jpg (887x535, 140.44K)

Found the archive of the second thread for anyone that wants to see why the LISPfag is running so much damage control.

archive.is/oUEwA

Attached: LaughingGas.gif (500x281, 694.84K)

I love these threads. Lispnigger v. Anti-lispnigger drama always cracks me up. But yeah, Lisp is for faggots and pseudo-academic retards. Program in superior C/C++, the white man's language.

Attached: lispniggers btfo.mp4 (1280x720, 8.17M)

why do you ignoring all points? also, why do you keep on madposting? are you butthurt, perhaps? well, congratulations, hothead, you got yourself caught. you are the only one who hasn't posted any reasons why lisp is bad. the user posted the editor in the last thread, and multiple anons pointed out both ITT and in the previous thread that both emacs and light table are programmed in lisp. why those editors don't count?

the only reason why you keep on madposting and doing damage control is that you aren't even interested in discussing anything.

Attached: Samefag_Matrix.jpg (1024x768, 174.9K)

Post your code, LISPfaggot.

It's in the archive I posted and no it doesn't meet all the requirements.

Guess how I know you're the faggot that sperged in the first two thread?

Attached: lispfagismad.png (1806x392, 256.65K)

The point of the first two threads was for (((you))) to show why it's good. Instead you cried samefag, goalpost moving, and called everyone a LARPer without producing any code yourself.
Which failed to meet the requirement of feature parity with notepad. It took some fag 3 months to produce a text box that couldn't even save data.
Because the point of the thread was for (((you))) or any other faggot to produce a simple text editor in a language you constantly shill as simple and superior to everything else. The OP stated existing projects wouldn't be accepted. Instead of taking up his challenge you shit up two threads with your butthurt, slid them off the catalog, failed to produce something that met the requirements after several months, went on to state it was good enough and cried any time someone criticized the shitty code. A pajeet could have made something that met the requirements in javascript in an afternoon. You couldn't do it in 3 months in LISP.

I don't even care about retarded language wars but I enjoyed watching you fail just like I enjoyed watching you sperg every time I bumped the thread just to see if I could farm more replies out of you. So far you haven't disappointed.

Attached: 1458566683115.png (1280x720, 698.28K)

If you aren't programming in MATLAB you are probably a useless faggot not doing real computer science, instead mindlessly sucking cum from your fingers as you try to one-up others about your useless language.

99% of software engineers only create technology for literal, actual niggers to send pictures of their genitals to each other. You are pathetic sub-140 IQ faggots and I hate all of you.

you seem genuinely upset. You might want to mention it to your doctor. The HRT can have sometimes effects on the stability of your mood. Good luck.

no u

Nigger nigger nigger nigger nigger cring baste baste golpust

Stfu snf

can't afford mathematica?

:- module ed.:- interface.:- import_module io.:- pred main(io::di, io::uo) is det.:- implementation.:- import_module list, string, maybe, bool, exception, int.:- type editor ---> editor( filename :: maybe(string), file :: list(string) ).:- pred load(editor, editor, io, io).:- mode load(in, out, di, uo) is det.:- pred write(editor, editor, io, io).:- mode write(in, out, di, uo) is det.:- pred print(editor, io, io).:- mode print(in, di, uo) is det.:- pred edit(int, string, list(string), list(string), list(string)).:- mode edit(in, in, in, in, out) is det.:- pred replace(string, string, editor, editor).:- mode replace(in, in, in, out) is det.:- pred ed(editor, io, io).:- mode ed(in, di, uo) is det.main(!IO) :- io.command_line_arguments(Args, !IO), ( if Args = [Filename] then some [!E] ( load(editor(yes(Filename), []), !:E, !IO), ed(!.E, !IO) ) else if Args = [] then ed(editor(no, []), !IO) else io.progname_base("ed", Program, !IO), io.format(io.stderr_stream, "usage: %s []\n", [s(Program)], !IO), io.set_exit_status(1, !IO) ).load(editor(no, _), _, !IO) :- throw(software_error("loaded without a filename")).load(!.E @ editor(yes(Filename), _), !:E, !IO) :- io.open_input(Filename, OpenRes, !IO), ( OpenRes = ok(Stream), read_lines(Stream, Lines, !IO), !E^file := Lines ; OpenRes = error(Error), warn_open(Filename, "input", io.error_message(Error), !IO) ).write(editor(no, _), _, !IO) :- throw(software_error("write without a filename")).write(!.E @ editor(yes(Filename), _), !:E, !IO) :- io.open_output(Filename, OpenRes, !IO), ( OpenRes = ok(Stream), foldl(io.write_string(Stream), !.E^file, !IO), io.close_output(Stream, !IO) ; OpenRes = error(Error), warn_open(Filename, "output", io.error_message(Error), !IO) ).print(editor(_, Lines), !IO) :- foldl(io.write_string, Lines, !IO).edit(LineNo, Line, Pre, [], L) :- ( if LineNo =< 0 then list.reverse([Line | Pre], L) else edit(LineNo - 1, Line, ["\n" | Pre], [], L) ).edit(LineNo, Line, Pre, [H | Post], L) :- ( if LineNo =< 0 then L = list.reverse(Pre) ++ [Line | Post] else edit(LineNo - 1, Line, [H | Pre], Post, L) ).replace(From, To, !E) :- foldl((pred(!.Line::in, Acc::in, [!:Line | Acc]::out) is det :- string.replace_all(!.Line, From, To, !:Line) ), !.E^file, [], Lines), !E^file := list.reverse(Lines).ed(!.E, !IO) :- io.read_line_as_string(Res, !IO), ( Res = ok(String), Line = chomp(String), Cmd = split_at_separator((pred(' '::in) is semidet), Line), ( if Cmd = ["p"] then ed.print(!.E, !IO) else if Cmd = [NStr, "r" | Replace], to_int(NStr, N) then edit(N, join_list(" ", Replace) ++ "\n", [], !.E^file, Lines), !E^file := Lines else if Cmd = ["w"] then write(!E, !IO) else if index(Line, 1, Sep), ["s", From, To, ""] = split_at_separator((pred(C::in) is semidet :- C = Sep), Line) then ed.replace(From, To, !E) else io.print(Cmd, !IO), io.write_string(io.stderr_stream, "?\n", !IO) ), ed(!.E, !IO) ; Res = eof ; Res = error(E), io.format(io.stderr_stream, "got error reading editor command: %s\n", [s(io.error_message(E))], !IO) ).:- pred read_lines(io.text_input_stream, list(string), io, io).:- mode read_lines(in, out, di, uo) is det.read_lines(Stream, !:L, !IO) :- read_lines(Stream, [], !:L, !IO), list.reverse(!L).:- pred read_lines(io.text_input_stream, list(string), list(string), io, io).:- mode read_lines(in, in, out, di, uo) is det.read_lines(Stream, !L, !IO) :- io.read_line_as_string(Stream, Res, !IO), ( Res = eof, io.close_input(Stream, !IO) ; Res = ok(Line), read_lines(Stream, [Line | !.L], !:L, !IO) ; Res = error(_), throw(Res) ).:- pred warn_open(string, string, string, io, io).:- mode warn_open(in, in, in, di, uo) is det.warn_open(Filename, Use, Reason, !IO) :- io.format(io.stderr_stream, "failed to open %s for %s: %s\n", [s(Filename), s(Use), s(Reason)], !IO).

as used for the task:$ wc -l linux.txt ; grep -c Linux linux.txt ; grep -c GNU/Linux linux.txt 21 linux.txt60$ ./ed linux.txt 25 r --end--s,Linux,GNU/Linux,w$ wc -l linux.txt ; grep -c Linux linux.txt ; grep -c GNU/Linux linux.txt 26 linux.txt66

No they weren’t. The OP of those threads had a clear set of requirements that weren’t met. What’s your goal, revisionist?

At least someone posted code. I'll run it tomorrow to see how well it works. It's good to see a few anons are still around that want to actually discuss Zig Forums. The board has really gone to shit over the years. The tripfags were bad and they just became worse after their precious trips were taken away. I'm pretty sure they're the ines that constantly derail every thread in some lame attempt to get revenge. The BO is hands off and too busy namefagging on IRC to give any fucks about what goes on here.

LOL is this Erlang or some other Prolog variant?

The board has gone to shit because of threads like this and LARPers like you.

Mercury. It's like a purely functional prolog.
The ed-like challenge is easy. There's still no Lisp candidate for it? Instead you went and made a thread asking for non-Lisp code? Are you really even a fan of the language?

Oh boy that was like the first thing lispfags tried to shill as their solution, too bad much of its codebase is in C.

They could make it glorious and gigantic for all I care but they can't even make a simple one so they were given guidelines they could focus on.

Assmad over what? Over utter incompetence of people thinking they are super hackers with magic super language? But I'm not one of them.

I think even that is irrelevant, but nothing really exists. They tried to offer that Climacs editor as ancient solution ("development" had started like 20 years ago), but turned out it didn't even compile and and its git commit history was absolutely hilarious, it was some European professors eternity project to (I assume) get his salary so it was more important he commits anything often than make it work and usable.

I agree, then again it's easy to forget when looking at simple notepad.exe that there are actually super hackers in this world who can't replicate that in one lifetime using super magic language Lisp.

Emacs was never 100% Lisp no matter how much you scream otherwise, anyone can check its sources, and Zmacs is ancient software that doesn't run and thus doesn't fulfill basic requirement of run and compile has to be verifiable. Zmacs cope is pretty much equivalent to we wuz kangz cope, nevermind how retarded and incompetent we are now, we used to have this cool wall painting 5000 years ago look look.

These threads are better criticism of it than anyone could ever write, proof is in the pudding. You are owning yourselves with every single post you make. That it turned out like this is nobody's fault but yours. It all started with a simple innocent question, don't forget that. Rest is all on you.

This. It was equivalent of making text box in HTML and saying "now imma real JavaScript pro"

Nice! I have the first one: archive.is/mnbNo
"You have absolutely no clue how Lisp works." makes me lmao every time.

This is just sad projecting holy shit.

To be fair those set requirements came later, but they were made because there was no end to their desperate slide attempts, nervous hand-wringing and sweaty kvetching.

Attached: 1537411449337.jpg (640x932, 90.67K)

(defun file-to-lines (file) (let ((line (read-line file nil))) (if (null line) nil (cons line (file-to-lines file)))))(defun find-and-replace (string find replace) (let ((found (search find string))) (if (null found) string (concatenate 'string (subseq string 0 found) replace (find-and-replace (subseq string (+ found (length find))) find replace)))))(defun ed-print (lines) (map nil (lambda (line) (format t "~d~%" line)) lines))(defun ed-replace (lines n line) (if (< (length lines) n) nil (setf (aref lines (1- n)) line)))(defun ed-write (lines name) (with-open-file (file name :direction :output :if-exists :supersede) (map nil (lambda (line) (write-line line file)) lines)))(defun ed-find-and-replace (lines find replace) (map-into lines (lambda (line) (find-and-replace line find replace)) lines))(defun ed-is-print (input) (string-equal input "p"))(defun ed-is-replace (input) (let ((split (search " r " input))) (and (not (null split)) (not (null (parse-integer (subseq input 0 split) :junk-allowed t))))))(defun ed-is-write (input) (let ((size (length input))) (and (>= size 0) (eq (char input 0) #\w) (not (eq size 2)) (or (eq size 1) (eq (char input 1) #\space)))))(defun ed-is-find-and-replace (input) (let ((size (length input))) (and (>= size 5) (eq (char input 0) #\s) (eq (char input 1) #\/) (not (null (find #\/ (subseq input 3 (1- size))))) (eq (char input (1- size)) #\/))))(defun ed-parse-replace (input) (let ((split (search " r " input))) `(,(parse-integer (subseq input 0 split) :junk-allowed t) ,(subseq input (+ split 3)))))(defun ed-parse-write (input def) (if (eq (length input) 1) def (subseq input 2)))(defun ed-parse-find-and-replace (input) (let ((split (+ (position #\/ (subseq input 2)) 2))) `(,(subseq input 2 split) ,(subseq input (1+ split) (1- (length input))))))(defun ed-repl (lines name) (let ((input (read-line *standard-input* nil))) (if (null input) nil (progn (cond ((ed-is-print input) (ed-print lines)) ((ed-is-replace input) (apply #'ed-replace (cons lines (ed-parse-replace input)))) ((ed-is-write input) (ed-write lines (ed-parse-write input name))) ((ed-is-find-and-replace input) (apply #'ed-find-and-replace (cons lines (ed-parse-find-and-replace input))))) (ed-repl lines name)))))(defun ed-start (name) (let ((file (open name :if-does-not-exist nil))) (if (null file) (ed-repl (make-array 0) name) (let* ((lines-list (file-to-lines file)) (lines (make-array (length lines-list) :initial-contents lines-list))) (close file) (ed-repl lines name)))))(defun main () (let ((args (or #+CLISP *args* #+SBCL *posix-argv* #+LISPWORKS system:*line-arguments-list* #+CMU extensions:*command-line-words* nil))) (if (null args) (format t "~d~%" "Your implementation of Common Lisp is not supported") (ed-start (cadr args)))))

Maybe lispfags just need very simple instructions to follow. How about this pic related? You can do it, come on little buddies.

Attached: COLTE - Copy.png (575x396, 16.74K)

i just dont get it

You missing out on the best on-going cringe show on the web bro, here
Ep.1: archive.is/mnbNo
Ep.2: archive.is/oUEwA

How delusional are you? Do you really think that someone still takes (((you))) seriously. You have proven countless times that you don't even know why you hate lisp. Also, the challenge was completed in previous thread and you lost. Actually it was completed long before you even posted it, since emacs exists

Yes it is. The only thing that is in C is the kernel. But I guess you will ignore that too. I wonder if the unixhater was right all along and Unix really causes braindamage.

UNIX *is* braindamage

this works to replace Linux with GNU/Linux in the test file btw, surprisingly. s/Linux/GNU/Linux/ does the job. If you install SBCL you can try it out with: sbcl --load ed.lisp --eval '(main)' linux.txt
Speaking of s///, the code for this in Mercury vs. CL makes a nice point of comparison. On the one hand Mercury's lambda looks hairy af; on the other hand CL works so much harder to recognize and then parse the line that it's silly. Mercury does the recognition and parsing in one step, index(Line, 1, Sep), ["s", From, To, ""] = split_at_separator((pred(C::in) is semidet :- C = Sep), Line)whereas just recognition in CL is already(defun ed-is-find-and-replace (input) (let ((size (length input))) (and (>= size 5) (eq (char input 0) #\s) (eq (char input 1) #\/) (not (null (find #\/ (subseq input 3 (1- size))))) (eq (char input (1- size)) #\/))))
the point ofc isn't to perfectly implement the minimal ed-like editor. The point is implement version 0.0.0 of a useful vi-like editor. And CL's now done that. You can grow from here, implement ex, slap on a visual mode...
of course the real growing pains will be in changing data structures as you get serious about editing big files. I'd rather change data structures with a strictly typed language that had my back. Getting thrown into the Lisp debugger isn't all it's cracked up to be.

improved: index(Line, 1, Sep), ["s", From, To, ""] = split_at_separator(unify(Sep), Line)

Common Lisp is strictly typed. You mean static rather than dynamic.

the absolute state of lispfags jesus christ, this isn't even retarded anymore, this is pure mental illness

nice madpost

Dude, you are claiming that a program that has its core part made in C is still somehow 100% Lisp. That is literally insane.

I'm not sure what's more pathetic. That he's been pretending to be retarded for month after month or that he's not and is genuinely this delusional. I almost wonder if fags are trying to ape Terry's behavior for attention or to fit in.

Misreplied, meant to reply to

gj user. I was half-way through writing my scheme version.

What's more important is someone giving it a GUI.

if Emacs were a painting that you put up on a wall to admire, then the C part would indeed be a big problem. It'd be like graffiti, or a splotch from someone spilling a chemical on the painting.
But Emacs is a program and programs move. If you care deeply about Emacs and want it improve it, you'll pretty never touch C. Your problem is never going to be related to the C. You're never going to troubleshoot into the C. So for practical purposes it doesn't matter in the slightest. The reality of hacking Emacs is that you're hacking Lisp.

save that for when you reimplement krita or inkscape or something.

No you don't. Terminal paints are fine. It's a perfect match of block to pixel. Also it's the Unix way. I can easily run paint from my terminal whenever I want instead of having to call a program and then wait for it to load, enjoy your bloat. Oh wait are you too much of a pleb to paint in the terminal lmao go back to Ubuntu nub.

Hahaha what a fucking lie. Yeah, I'm sure to port Emacs to X11 and add image support you didn't have to modify the C part.

You don't. All you have to do is insert the X11 calls to the graphical output of Emacs. The C kernel of Emacs doesn't deal with that.

What the hell is this terryposting? After failing to convince sane people that program with its core part in C is in fact 100% Lisp anyways, you start rambling complete nonsense.

lel.

literal braindamage

It's funny that you never post code or original thoughts. You just call other people LARPer and post 30 year old mailing list posts. You're the cancer.

You also never post code

I remember the thread where the lispfag posted his editor. Everyone made fun of him because it was large as fuck, like 10mb or so and was extremely slow, 1mb txt file would freeze it. I remember I posted my 5 minute effort made in autoit (BASIC kind of language) that together with the interpreter was below 0.5mb and didn't have a problem with large text files. Lispfag didn't respond to this as far as I remember, so don't say nobody posted their own editor in the thread...

"Lispfag" that made shalompad here. Funny thing is that was my first program written in racket or any kind of lisp language. It was literally copy and paste from documentation, I actually kinda liked it how easy it was to make GUIs. The editor did everything OP asked for, but then the goalposts started moving, muh not all notepad features were implemented, muh bloat, muh freezes. It's a pointless task to complete. This was all just shitposting.

...

...

...

...

It was nowhere near 80%. That Racket thing was equivalent to HTML text box in a browser.

You posted it after goalposts were set and nobody moved them but asked you to keep developing it to reach goalposts, at which point you threw autistic fit that continues to this point. But it did reveal how shit Racket is in a way for requiring that entire fucking system to run anything, what was it, 300MB install, and people are looking forward to usable application they can just run, it was in goals. You did good otherwise and your attempt proved very educational (just didn't prove anything positive about Racket). Keep trying buddy.

Attached: 1523040788433.jpg (368x535, 29.28K)

...

...

It could open, modify and save local files. That's somehow equivalent to HTML text box in a browser?
That was solved once I figured out how to use their packaging tool, but you started sperging out about search functionality being just a placeholder item in the menu.
Still butthurt after so much time has already passed. We've solved your soydev challenge, nobody is going to waste time pleasing a sperg on the internet.

Yet you keep trying. Do you have daddy issues?

Attached: smug (285).jpg (328x285, 74.24K)

I'm just here for the (You)'s.

Did you actually develop it further? Post sources, instructions to build it and executable. I'll take a look.

No, but the source should be in the original thread, I don't have the files anymore.