Birbla

Discussion summary

Lore is an open source version control system aimed at scalability, with some users comparing it to existing tools like SVN and Git. Opinions are mixed, with concerns about pricing, lock-in, and effectiveness.

What the discussion says

  • Some users see Lore as a scalable alternative to existing VCS like SVN and Git.
  • Concerns about potential licensing costs and lock-in, especially related to Unreal Engine.
  • Others highlight that Lore is MIT licensed and compare it to other tools in game development.
“It's MIT licensed, which is good.”
— shepardrtc
“Pricing for on-premise deployment is 'talk to us'.”
— schaefer

Join the discussion

Write your take first — we'll ask for email only when you're ready to publish.

Sign in
  • Hacker News
  • "Full-surface API" is a feature nobody here has mentioned. Is that a dig at how git intentionally has no linkable library? I saw this earlier https://news.ycombinator.com/item?id=48470604
    by frollogaston
  • The premise is that Git-LFS sucks, so we need to build a new data versioning system (in Rust, from scratch). While I mostly agree with this premise, but there are already lots of existing (mature) data versioning systems with the same tricks under the hood:

    - Pachyderm (Go): https://github.com/pachyderm/pachyderm

    - XetHub (acquired by HuggingFace): https://huggingface.co/blog/xethub-joins-hf

    - LakeFS (Go): https://github.com/treeverse/lakeFS

    - Oxen (Rust): https://github.com/Oxen-AI/Oxen

    I guess with AI, anyone can vibe code a content-addressed, chunk-level deduped, versioning system in Rust these days...

    But jokes aside, Lore seems really cool! What's interesting is the realization that different domains/industries have similar problems, but they don't seem to be cross-polinating. In this case AI and Gaming both need a storage system that can version control large binary files at scale. I think there's lots of opportunities to share ideas here, but perhaps the lack of idea sharing (currently) creates opportunity!

    by penciltwirler
  • I'd trust this project more if it was named Data.
    by jacobgold
  • Turns out it is not really new but only open sourced it now. From the FQA.

    >Lore, formerly called Unreal Revision Control, is the built-in version control system for UEFN (Unreal Editor for Fortnite), where creators have been using it to version their islands. It is also seeing progressive adoption by internal Epic teams, and is being implemented as the backing store for UEFN’s cook pipeline, where it replaces traditional intermediary storage layers—eliminating redundant file transfers and significantly reducing the time between publishing changes and those changes being playable.

    Surprised it is in Rust and not Epic C++ or Verse. I wonder why.

    by ksec
  • We had to use Perforce (Helix Core Cloud) at my last game studio, and it is the de facto industry standard that most of your creative staff is already familiar with. The programmers don't love it, but they don't rule the roost in games. It's also the safe, verified default for working with Unreal Engine 5.

    It does show its years though. We were one of the first users of the Perforce cloud offering, as we were small and didn't want to self-host ourselves, but it was a bit of a rickety experience. You had to register an Azure account in order to be able to access the service, and you had to ask support to modify things like triggers. Coming from the world of GitHub and other SaaS products, you could tell it was an attempt to retrofit an older model into a new skin.

    The Git LFS path has some unofficial support as well, but you are on your own when things go poorly. Epic doesn't provide much help there.

    Competition in this space is welcome, especially if they're planning to make it fully officially supported by the Engine.

    I wrote about why merging files isn't as common in the world of game dev for folks coming from the world of text: https://www.kuril.in/blog/why-game-devs-dont-merge-files/

    by akurilin
  • This is a very promising announcement for Unreal game development specifically. For any other purpose I wouldn't care as much.

    Perforce definitely needs a challenger. It is not the incumbent because it is particularily simple to use or administer. Git is actually way simpler when it comes to branching operations for example.

    The reasons why p4 is often preferred in gamedev have already been mentioned in other comments: large project support, permissions, file locking and so on. Another key reason p4 is the king for Unreal dev is just how well it's supported inside the engine. Not perfect, but it's the best supported VCS because it's what Epic uses. Even the Git plugin is painfully unfinished, because Epic does not internally use it. So with Lore I expect them to give it first class support. I'd recommend Git a lot more if the support in Unreal was better.

    (background; I've been in gamedev for almost two decades now, 2-200 person companies, every kind of engine and version control system. I prefer git where I can use it: for Unreal that means small projects and/or tech savvy team members. Pick the tool that is right for the job and the team.)

    by tlahtinen
  • Just today as I pushed some changes to Github, I was thinking how user-unfriendly Git's UI is:

        Enumerating objects: 5, done.
    Counting objects: 100% (5/5), done.
    Delta compression using up to 10 threads
    Compressing objects: 100% (3/3), done.
    Writing objects: 100% (3/3), 290 bytes | 290.00 KiB/s, done.
    Total 3 (delta 2), reused 0 (delta 0), pack-reused 0
    remote: Resolving deltas: 100% (2/2), completed with 2 local objects.
    I know all of these things communicate something to the die-hard Git user, but for most people (even most people using Git, I bet) this is just complete gobbledegook. What the hell is "delta compression"? Why do I care how many threads it's using? What is an 'object' and what does it mean when it's 'local'? What does 'pack-reused' mean?

    From the documentation, it looks like Lore does a bit better in this regard:

        Pushing 1 fragment(s)
    Pushed 1 fragment(s), 124.00 bytes
    Pushing a3f8c2d1... to branch main
    Pushed revision 1 -> a3f8c2d1... to branch main
    by niek_pas
  • For context, since a lot of people on HN haven't worked on games - this is not intended to compete with Git for general software development. This is a competitor with Perforce for game development.

    Git is fine for text based files like code, but it's really bad at stuff like textures, 3D models, audio files, and other non-text files that game developers need to collaborate on. For example, one artist might need to obtain an exclusive lock on some art assets while editing them, because there is no sane way to merge two artists' async edits.

    The SOTA in this area is Perforce (https://www.perforce.com/products/helix-core), a proprietary system. From what my gamedev friends tell me, when Perforce works it's great, but it hits enough snags that you need a tools engineer to manage it and occasionally fix issues manually. Git LFS is an alternative, but my gamedev friends all prefer Perforce especially when working on team projects beyond like 3-4 people.

    by throw2ih020

Explore Birbla archives