Lisp machine is certainly possible. There was a bootleg of the original Lisp Machine ported to some ancient Ubuntu version circulating at some point.
There is no need for FPGA to run Lisp, you can run Emacs on pretty much any system.
As to if it is desirable the short answer is, in my opinion, no.
The Lisp machine was not wonderful because it was running Lisp, the wonderful features had nothing to do with Lisp at all.
One feature that was often cited is that the machine would never ‘crash’ in the sense of throwing everything away and starting from 0 as is common with most OSes today. The Lisp interpreter would throw some sort of errors or exceptions, and if not handled you would get back to the debugger/shell/IDE where you could inspect the machine state, and continue execution of the program. This is common behavior for Lisp interpreters but is in no way a feature of the language itself. While this is not something that can be easily achieved with assembly or C programs pretty much any managed language runtime could do it.
Another feature is language uniformity of the system. While some low-level parts of the Lisp machine were written in assembly or C vast majority of the system was written in Lisp - applications, libraries, everything. The shell would be the IDE/debugger where you could evaluate Lisp expressions or run applications which would really be more complex Lisp expressions. If you installed a library it would be available to applications as well as the shell.
The reason why Lisp is not the best language is that language theory advanced since Lisp was invented.
To understand the problem an excursion into history is needed. First we start with the story of Mel https://www.pbm.com/~lindahl/mel.html to understand what are ‘separate constants’. Assembly language using symbolic names for instructions is a higher level language than machine code. Using this higher level language imposes some structure. Because the value used to encode the instruction is obscured by a symbolic name it is no longer possible to, say, multiply by an instruction that happens to be encoded as the value you want to multiply by, a ‘separate constant’ for the multiplier is needed.
And the bourne shell and other similar shells are the machine code of Unix. The data they operate on is completely unstructured. It’s all text. It can be interpreted as the name of the function(command) to call, as completely untyped argument, whatever.
There are many libraries that provide ‘tools’ that are conversion of their meticulously crafted API to this shapeless alphabet soup on which the shell operates. Of course, the experience is horrible for everyone involved. For the library writer finding ways to squeeze at least basic functionality into this alphabet soup interface, for the users using the resulting API that is inherently awkward and error-prone.
There is this bash-completion thing that is trying to add types to the alphabet soup API to help users to pass the right thing to the ‘tool’/shell function. Of course, because the completion is completely separated from the program itself it is always out-of-sync, glitchy, missing some values in enumerations, etc.
And Lisp is to shell what assembly is to machine code. It is slightly more structured. You no longer get shapeless alphabet soup, everything is an S-expression. Sexps are not typed in any way, you can pass any sexp to any function. However, they are no longer shapeless, you can pass your data structured in some way. Also unlike the unix shell the Lisp program is observable, good introspection features are the norm for Lisp. The types are, however, missing.
There is another thing that is missing in Lisp. Critical practitioners observe that while Lisp is the language of choice for the famous SICP book Lisp programs themselves lack structure. While it may be theoretically possible to write nicely structured programs in Lisp in practice any moderately complex project written in Lisp turns into an eldritch blob oozing parentheses on all sides with no structure to speak of. There is probably some lack of tools for modularity.
An example of a decent Lisp IDE is Emacs. It provides text editing, interpreting the text as e-lisp code, extending the IDE with code written in e-lisp. The fatal flaw is that e-lisp is not a general purpose language, it’s a language written specifically to run Emacs in and to extend Emacs with. You do not get general purpose libraries written in e-lisp. When you install ImageMagick you do not get to work with bitmap images in Emacs. Another fatal flaw is horrible UX.
So rather than a Lisp machine I would like to see something like Emacs built on top of a general purpose dialect of something like Haskell or ML where it’s possible to take a string like ‘README’ and say that from now on it’s a filename, and can be passed only to functions that want a filename, and not to functions that want a string. And hopefully get at least some libraries for free because people wrote them for their existing applications, because it’s a general purpose language, and not a language specifically made to write an IDE in.