Castle Game Engine

Wow, cool! Have any playable games been made with Castle? I loved spending some time with Delphi when I was learning to program. What’s the state of Pascal these days? Edit: I see they have a gallery of games some of which are published on Steam and on the Switch: https://castle-engine.io/gallery_games.php

The Castle Game engine is not mentioned often, but it looks pretty mature from the screenshots and has been in active development for many years. Most recent news update was a few weeks ago. I have not gotten around to try it yet. Only started playing around with FreePascal a bit last year after not having used Pascal at all for some 25 years. https://castle-engine.io/

The Castle Game Engine mentioned in one of the courses sounds interesting. https://castle-engine.io/

Since this is a pretty general thread about Pascal, shout out to Castle Game Engine: https://castle-engine.io/

If anyone would like to learn a bit more about Pascal, have a look here for something pretty up to date: https://castle-engine.io/modern_pascal_introduction.html As for the IDEs, Lazarus is indeed a great option, allowing for both desktop software and most other kinds of development (though admittedly Pascal's strengths don't lie in webdev): https://www.lazarus-ide.org/

Seems Pascal is having a field day today. Makes this old Pascal fan happy! The other piece is about Castle Game engine, written by the same author, Michalis Kamburelis. About the only issue I'd take with this piece, and it's minor, is that it's slightly modified from the original and pushes the use of Delphi mode over the default ObjFPC mode in the Free Pascal compiler. To see the original: https://castle-engine.io/modern_pascal_introduction.html While there's nothing wrong with preferring Delphi mode or ObjFPC mode, since the differences between them aren't that great [1], a piece that aims to describe the language should at least offer some rationale for a preference that is urged so strongly on readers. But otherwise this is an excellent piece for anyone wondering what Pascal looks like in 2020. [1] https://www.freepascal.org/docs-html/prog/progap4.html#progse62.html

What's why I love Object Pascal/Delphi - good balance between abstraction and the underlying system, compile to native code, with an clean, easy language syntax: https://castle-engine.io/modern_pascal_introduction.html

For anyone looking for a proper, "modern" introduction to Object Pascal, as found in FPC/Lazarus, don't miss this excellent guide: http://castle-engine.io/modern_pascal_introduction.html

Ok I’ve got a hacker challenge for the more creatively-inclined: if I wanted to stretch “cross platform” to web (and thus webVR?), how might I wrap/integrate/emulate/polyfill/whatever this? EDIT: after a quick search the answer is a resounding “you can do it, but yikes.” Multiple people reference custom compilers, which I’m guessing are beyond my reach… https://news.ycombinator.com/item?id=12029566 EDIT 2: wow nvm it’s on their roadmap! Their “why pascal” page says it’s already supported, but i think thats more hopeful than contractual. Coming soon (roadmap): Oculus (VR) (we have the hardware to test) WebGL (FPC can compile to WebAssembly) XBox (we have the hardware to test). (Love the casual “we own at least one xbox” humble brag. If the authors are reading this, that’s the only part that I find a tiny bit off putting — a tinge of overeagerness to persuade me / sell me.) https://castle-engine.io/features#_cross_platform Highly recommend the “Why pascal” page in general, the most interesting part of the project to a passerby like me: https://castle-engine.io/why_pascal

It's alive and kicking, right? :) https://www.freepascal.org They even have a game engine that can compile to a WASM target: https://castle-engine.io/web

Author articulates why he programs in Pascal: https://castle-engine.io/why_pascal

How new is this engine? It was renamed to "Castle Game Engine" (from "Kambi VRML Game Engine") in 2011. Version 1.0.0 was released in 2007. Not sure if there were even older releases? https://castle-engine.io/old_news.php?id=2011-8-22-engine_rename_to__c… https://sourceforge.net/projects/vrmlengine/files/kambi_vrml_game_engi…

I searched around and found this tutorial[0] on the official wiki. Seems like a decent intro to the history & syntax of the language. There’s also another tutorial[1] on the more modern iteration of the language, as well as some video tutorials[2] on using the IDE for GUI development. [0]: https://wiki.freepascal.org/Basic_Pascal_Tutorial/Introduction [1]: https://castle-engine.io/modern_pascal [2]: https://wiki.freepascal.org/Lazarus_videos

https://castle-engine.io/why_pascal I'm gonna have to put a damper on things, here. Most of the reasons listed are things available in any other modern language (safety, cross-platformness, libraries...) but one of the things cited is readability. I work on Pascal code 8 hours a day, and it is not more readable then conventional C syntax ; I'd argue it's much less. The fact that you need to use entire words to denote syntax makes it much harder for your brain to parse things : Instead of immediately seeing "this is code structure" and "this is actual code", you need to actually read the words to make that distinction. It is very counter-productive and a bad design solution, imo. I feel like this page was written 20 years ago. The reasons would have made quite a lot more sense back then, notably about the type safety.

Here's a bunch, in no particular order: https://godotengine.org/ https://o3de.org/ https://defold.com/ https://www.stride3d.net/ https://gdevelop.io/ https://armory3d.org/ https://torque3d.org/engine/ https://flaxengine.com/ https://pragma-engine.com/ https://wickedengine.net/ https://www.adventuregamestudio.co.uk/ https://castle-engine.io/ https://solarus-games.org/

We consider it a modern, OOP, native (fast), type-safe, cross-platform programming language :) You're welcome to learn more about Pascal on https://castle-engine.io/modern_pascal .

What's wrong with Object Pascal? "Plain" Pascal is about as efficient as C, uses slightly less memory, is safer because of its lower dependency on pointers, and is easy to work with, especially with strings. Then Object Pascal has classes, units, interfaces, generics and type safety. Is it still not enough? https://castle-engine.io/modern_pascal An alternative would be to build a Go program with a wish/tk frontend, which is also cross platform, native and simple to write. It's actually straightforward to do with go-pipes for the binding with wish, and provides a nice decoupling between the program and its UI. Also, it's fairly small and efficient unlike Qt, or worse, web technologies.

There are a few more choices in this space--someone mentioned Zig; there's also Nim, OCaml, Go, and even a super-old language that has a modern and well-maintained variant: Object Pascal. Check out https://castle-engine.io/modern_pascal_introduction.html

Perhaps this one: https://castle-engine.io/modern_pascal_introduction.html Or this with Delphi syntax for generics: http://newpascal.org/assets/modern_pascal_introduction.html

Probably most interesting is the gallery (games using the engine): https://castle-engine.io/gallery_games.php

The most interesting part for me is that the scene graph is based on X3D, a successor to VRML: https://castle-engine.io/vrml_x3d.php

I like Pascal for its simplicity and clean syntax. The modern Pascal is not the same old language as in Borland's Turbo Pascal from the 80s, it's developing, it even has generics - see the "Modern Pascal Introduction" article[0] by Michalis Kamburelis. Also, quickly (or rather rapidly, as in "RAD") creating truly native and cross-platform GUI applications using Lazarus IDE is the killer feature for me. [0] - http://castle-engine.io/modern_pascal_introduction.html

Obligatory https://castle-engine.io/modern_pascal

There is also this https://castle-engine.io/modern_pascal

I was eyeing Lazarus, because it is close to my particular crossplatform toolkit ideal. I think that UI toolkit should use native widgets and near zero cost FFI. So any toolkit that draws for itself is not within my ideal. The most problematic platform for my ideal is Android as the toolkit should run without NDK. C++ does not cut it. Java would work for Android, but on other platforms there's FFI. FreePascal does compile to Java bytecode. It is an experimental feature as far as know, but it's promising. There is lots to like about FreePascal, even if I dislike the syntax a bit. See the Modern Object Pascal Introduction¹ for reference. But memory handling is something that does not fit my vision. I would hope for something similar to Swift - automatic reference counting. I like that the compiler is not LLVM or GCC based. With ARC I can forgive even the manual UUIDs for components. That's how I saw it from quite a big height so excuse me if I'm misguided. At the moment Swift looks promising for me without possible transpilation to Kotlin as seen in one project ². Or D, as it should be easier to fit Java. But I have my eye on Lazarus. It certainly is much more mature a project. ¹ https://castle-engine.io/modern_pascal_introduction.html ² https://github.com/angelolloqui/SwiftKotlin