I finally managed to progress to the point where I can integrate all the bottom-up components (yes, I know that this is the wrong way to build things but I wanted to experiment with whether each idea would work since many were new to me) into a top-down design for the client and server.

Now, the actual main for each is not yet built, nor is there a client-side UI, nor are the tests currently using the real network layer but I am finally to the point where all of the logical components are finally connected and can be tested, together, across multiple clients against a shared server.

Another interesting thing I was reminded of, while building out this integration point, is that bottom-up design approaches lend themselves to trying to solve problems in complicated ways where a top-down approach lends itself to more elegant solutions. An example of this is the 2-phase change processing system: The original solution to this was bizarre and complicated since the core logic engine needed to re-materialize or track a bunch of per-client state data. When building this integration, I realized that the solution is much simpler when implemented in a component which is directly connected to other per-client concepts (as it is a client-server sync problem, not a problem with in-universe logical elements).

With this milestone, the options for the next direction really ramp up but I think that this is my plan:
1) Next step will be fleshing out more of the high-level change types and basic game rules (like how gravity works, etc)
2) Build the basic first cut of an interactive UI (after this, the system will be loosely "playable")
3) Build out the first cut of the crafting system (both in-entity 2-phase crafting but also some machine-oriented in-world crafting)
4) Performance stress testing to make sure that this parallel logic core is actually being effectively utilized

Beyond that, the only requirements for October Plains (the first planned "release" on this technology) will be content (more blocks, crafting, world gen, graphics, etc) and polish of the interface and mechanics.

Still, what I have described here is a few months of work but I hope that step (2) can be completed sometime in January. I suspect that this will be around the point where I will publish the source to GitHub and continue the project in the open. The only reason to hold off is that I am still not sure that this will become "real" and I dislike leaving half-baked projects out in public since looking at them is only a waste of time (and I have a few of those out there).

Lots to do but it is at least moving forward,
Jeff.