Skip to content
Entity Component System focused on usability and speed.
Rust CSS
Branch: master
Clone or download

Latest commit

Latest commit f422f99 Mar 17, 2020

Files

Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.github/workflows specify bunny demo name Feb 29, 2020
book
demo
shipyard_proc fix import bug Mar 1, 2020
src reworked pack_info module Mar 17, 2020
tests
.gitignore gitignore static wasm Jan 24, 2020
Cargo.toml
LICENSE-APACHE add README and licenses Aug 9, 2019
LICENSE-MIT
README.md move origin paragraph Mar 8, 2020

README.md

Shipyard

Shipyard is an Entity Component System focused on usability and speed.

LICENSE LICENSE Crates.io Documentation User's Guide Demo Chat

While usable it is far from finished, there's a lot of planned features, nearly all being backward compatible additions.

Most discussions about current and future features happen on zulip, feel free to join in to follow the development, ask any question or just say hi.

If you are new here, the user guide is a great place to learn all about Shipyard!

Simple Example

use shipyard::prelude::*;

struct Health(f32);
struct Position { x: f32, y: f32 }

#[system(InAcid)]
fn run(pos: &Position, mut health: &mut Health) {
    (&pos, &mut health).iter()
        .filter(|(pos, _)| is_in_acid(pos))
        .for_each(|(pos, mut health)| {
            health.0 -= 1.0;
        });
}

fn is_in_acid(pos: &Position) -> bool {
    // it's wet season
    true
}

let world = World::new();

{
    let (mut entities, mut positions, mut healths) =
        world.borrow::<(EntitiesMut, &mut Position, &mut Health)>();
   
    entities.add_entity(
        (&mut positions, &mut healths),
        (Position { x: 0.0, y: 0.0 },
        Health(1000.0))
    );
}

world.run_system::<InAcid>();

Past, Present and Future

I initially started to make an ECS to learn how it works. After a failed attempt and learning a lot from it and other ECS out there, I started to work on Shipyard.

Specs was already well established as the go-to Rust ECS but I thought I could do better and went with EnTT core data-structure: SparseSet.

It turned out to be extremely flexible and is still the core of Shipyard. You can pay for what you want: iteration speed, memory, ease of use,...

And it allowed amazing features:

  • No component boilerplate
  • Very simple systems
  • Powerful inner and outer system parallelism
  • Ability to add/remove components while adding/removing entities
  • Chunk iteration
  • And a lot more!

Today I wouldn't say Shipyard is better or worse than Specs, it's just different. I'm really happy with it and the future looks very promising, especially:

Similar Projects

  • EnTT - C++ library built on SparseSet and providing grouping functionality, a lot of its designs are explained in a blog. This is where Shipyard's SparseSet and most packs come from
  • Specs - Rust library relying on BitSet and allowing to use multiple storage types
  • Legion - Rust library based on archetypes
  • Hecs - Rust library also based on archetypes but keeping a minimalistic approach

Performance

If you're wondering how fast Shipyard is you can look at a few graphs in this issue.
There is still a lot of room for optimization, the current focus is more on adding functionalities.

Features

  • parallel (default) — adds parallel iterators and dispatch
  • proc (default) — adds system proc macro
  • serde — adds (de)serialization support with serde
  • non_send — add methods and types required to work with !Send components
  • non_sync — add methods and types required to work with !Sync components
  • std (default) — let shipyard use the standard library

Unsafe

This crate uses unsafe both because sometimes there's no way around it, and for performance gain.
Releases should have all invocation of unsafe explained.
If you find places where a safe alternative is possible without repercussion (small ones are sometimes acceptable) feel free to open an issue or a PR.

Origin of the Name

Assembly lines take input, process it at each step, and output a result. You can have multiple lines working in parallel as long as they don't bother each other.

Shipyards such as the Venetian Arsenal are some of the oldest examples of successful, large-scale, industrial assembly lines. So successful that it could output a fully-finished ship every day.

Shipyard is a project you can use to build your own highly-parallel software processes.

License

Licensed under either of

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

You can’t perform that action at this time.