Reference a branch in another library

+1 for the ability to publish branches. I mentioned it in the slack channel as well.

In addition to the use case mentioned by you @Bryan_Berger, in our case it would be to be able to create v2/vX of components with breaking changes for older files that depend on the old version of the components. The published branch would be used to get files up to speed to the breaking changes.

This is a great request. For now, we are trying to keep it as simple as possible, which means that only single files can be branched, and there isn’t a way to test out dependencies of the sort that you are describing.

We’ll think about this use case some more, but it’s likely that it will need to wait until after the launch of the initial version of branching. Thanks!

Wow, this is a great idea. +1. Totally get why it might have to wait and, IMO, worth waiting for. We (my team) were just discussing the possibility and benefits of publishing a branch of our library. We currently have a completely separate Beta library for this reason but it’d be great to just have a Beta branch and be able to cherry-pick changes from the Beta branch to merge into Main. Very similar to the way a Staging environment might work in a traditional dev environment.

Just to add to the use case, we were looking for something in the past that helped us pick a release date for a new design iteration for the clients/devs to see and use. And not be bothered with all the tinckering in the meantime. Branching was told to be the solution, which it could very well be. But if we can’t update the components definitions (in file A) while doing adjustments in designs (in file B), then we’re still stuck I think. Any in between solutions more than welcome.

Any new news on the plans of allowing for a branch using multiple files? Has been a while, not sure when Branching is going to be released as mentioned before you get a chance to look at it (not sure, but it might already be released :)).

Asking only because branching as a concept is currently not useable for us, since the libraries are not attached in the branche.

^very much this

I agree with Ben. Branching with multiple files would allow us to finally get away from Sketch + Abstract

Please add this. Without being able to use a branch of a library, it’s impossible to sanely work on a task that needs changes to a library and a feature file.

Please Jeebus, can this be a thing?

Any word on this Sho? this would be immensely beneficial to me…

Want to +1 using branches in other libraries/files!

Our use case is we have a figma workflow which intersects with design - so we do a LOT of testing in Figma. Testing to make sure layers are set up a certain way for developers, but we also need to test to make sure the applications can consume them properly.

Ideally we’d have a Test File that consumes the library, and for new features we could swap the branch out that we were looking at and test the branch directly before publishing it out / merging it.

Periodic reminder for the “stats”. Would still love to use branching, but can’t until it supports multiple files per branch (e.g. library + design file).

Sorry… No news yet. It’s a good idea, but there are lots and lots of good ideas, so we can’t do them all at once.

For now, the best workaround is to put the test file directly into the library file as a “test page”. Any local changes will show up on that test page even without having published the file!

@Sho_Kuwamoto I tried something like this. We have a few templates that are comprised of components and styles from multiple libraries. I pasted one in to our main “styles” library and changed some colors. The template is unaffected, because the color styles and components within that template first need to be republished in order for a color change to take affect. So, unless I misunderstood your workaround, I’m not sure there is a current solution for complex design systems constructed of multiple libraries.

Ah. If the components and styles are coming from multiple libraries, it may not be possible to do what I was suggesting above.

I’ve just started using branching in my company and this is definitely a feature that will be handy. My design system, components and user flows span many different files so being able to publish branches to test these changes would be super valuable.

I’d like to: branch a components file > make changes > test those changes in my design file by selecting the branch instead of the main as my library > commit or not commit > change my file back. Just seems great for testing.

Just keeping this beauty alive with again a (yearly) periodic reminder. Would still love to use branching (it would solve a couple of clear challenges for us in client-communication), but it’s still useless in it’s current state (as long as the linked libraries are not part of the branch…).

I’m out of votes but definitely need this. We’re considering dropping branches for component updates since we can’t work with WIP components.

The weird part for me is this, how can people use it without library support? Weird.

+1 to using a branch in a file. If you want to update your design system comprehensively there is no way to make a branch and then test it across your files. To my mind, if you can’t do this in a library, I’m not sure why you’d use branching at all.

Would love this feature! We are updating our brand design and have many many files connected that we would like to branch and test new updates on before merging. The only way we can see how we can do this now is to make copies of all the files, which seems like such a waste when branching IS available? Please look into this feature again! 🙂

This feature would help us tremendously when working on updating an existing feature in another file! I hope it’ll be added!!

I just convinced the whole company to start using Figma and I was convinced this was implemented so I tried to push for the organization licenses just for this! If branching proves to be useless with no library support we might all be forced to switch to the professional license 😕 Please this is crucial for any kind of version control using libraries

Don’t get your hopes up. Assume it will never arrive. You won’t get any communication about any plans or progress either. But fortunately we have the new Dev Mode!