A low level functional programming language based an idea of containers that define an immutable context (http://yig.bitpuffin.com)


#+TITLE: Yig

The jig is up!

* What?

  A general purpose function programming language with a very strong
  focus on performance and code correctness. The goal is to achieve
  better productivity when working on complex systems such as game
  engines by encouraging a style of code that is easier to reason

  A very important aspect is making portable code easier to write and
  maintain. This is achieved through implicitly inferred interfaces
  for "modules" so that you can easily replace one of your modules
  with one that only implements the functionality you use for your
  target platform. All without fiddling with headers or deleting
  functions from interfaces and such. If you want to enforce that a
  module conforms to an interface the language doesn't stop you from
  implementing this either.

  Yig compiles to native code but will also feature very strong
  abilities to run itself interpreted within itself for productive
  prototyping and when finished compiling to optimized release code
  *without needing to change any code*.

  The language strives to be as minimalist as possible. I have managed
  to compress many things that people don't realize are related in to
  the same thing. The syntax is really just a thin layer above how
  data flows through a program and code itself can be data, passed
  around, transformed, and turned in to code again.

  I am making this language for personal use and everything will
  likely be *subject to change* for a =64 bit C integer= time. If you
  can not use sed-like tools you should probably go away. Also don't
  expect me to fix any bugs you encounter unless you are willing to
  pay me. You should use this language at your own risk and may have
  to fix bugs yourself and submit them disclaiming all of your
  copyrights. I am _very_ pedantic about this.

* Why?

  After looking at many, *many*, different languages that I wanted to
  invest in for my grand future plans to revolutionize game devopment
  I found myself without an option. No language offered everything I
  need and want, only subsets. I want a low level language that
  doesn't waste time with garbage collection or other unpredictable
  things. Something that is pure and can provide strong static
  guarantees, or rather, let you implement strong static
  guarantees. Basically, anything the compiler knows at compile time
  it should be able to reason about. Instead of relying on arbitrary
  things like types that really can just be implemented in the
  language itself customized to the current purpose. It's just
  metadata after all.

  But to be honest I am probably just a control freak when it comes to
  art. I need to know the intimate details about how everything works,
  as that is what drove me to game development - fascination. I also
  demand the power to change anything for any reason. Which is
  possible with open source. But I hate reading other people's code
  when I am working

* License

  Yig is in the public domain as much as possible (CC0) check
  COPYING.txt for details.


** Is this language for me?


** Why open source if nobody should use it?

   Because it is good for portfolio reasons. And also I believe in
   sharing. That doesn't mean I have any interest in fixing your bugs
   for free or anything like that. Which is why I am discouraging you
   from using it.

** Can I contribute?

   In most cases the answer is no. But maybe if you are a game
   developer. One nice side-effect of the project being in the public
   domain is that in order to do a pull request you need to go out of
   your way to abandon your copyrights. I am very pedantic about this.

** Why the name Yig?

   I wanted something Lovecraftian, and Yig was basically the only
   thing that was short. You can also be punny with it and reference
   Will Smith music and say things. I guess it is also appropriate in
   regards to how a process flows around like a snake, but such
   thinking is maybe too abstract.

** Are you insane?

   Making a language for yourself is pretty crazy as it is really not
   a good business decision. However you can't help it if you have
   grand plans.