SFML Roadmap

[eXpl0it3r]

With SFML 2.6.0 finally out the door and SFML 3 development being in full swing, it's time to update the Roadmap planning.

SFML 2.6.1

We have identified and already fixed some build configuration issues and I'm expecting to see further reports over the next couple of weeks/months.
SFML 2.6.1 will only contain "important" bugfixes, with everything else landing on the master branch for SFML 3.

SFML 3

The overall goals have not really changed:

• Upgrading the SFML API for C++17
• Cleaning up redundant and deprecated code
• Adding features as we go along:
  • API breaking features only possible at a major version change
  • (low priority) Non-API breaking features

While we had in the past a lot of ideas for SFML 3, the current goal isn't to provide decade long massive update of SFML, but really to focus on the C++17 support, clean up and API breaking changes.

Here a few open points, which anyone can help out with!

• C++17 Support Solution Design - AKA How do we add C++17 to SFML?
• Finish supporting move semantics
• Remove default constructor for types that require a view into a resource
• And more...

In the first ever Maintainer Meeting, we've decided to not consider a (major) graphics API overall. This means, we'll not be rewriting or accepting changes to refactor the whole rendering API.

(click to show/hide)

I'd like to discuss the next few steps for SFML's development. I've worded it as if things are already decided, but in fact it's all up for discussion.

Let's start with the big elephant in the room: SFML 3


The bad news: It's impossible to integrate all the changes we have promised, discussed or wished for over the past years.
The amount of potential API changes and redesigns is too great to fit into one version of SFML.

The good news: It has become clearer over the past few years, that a lot of people have adapted the "new" C++ standards and are looking for APIs that do support modern C++ (e.g. move-semantics), but also don't feel particual motivated to contribute to "old" C++ code bases like SFML.


SFML 3 will first and foremost focus on introducing the C++17 standard to the SFML code base and to get rid of some baggage.
Additional API changes or redesigns have second priority on the list.

The overall goal is to accept that major version updates don't require massive library evolutions on the scale of barely achievable, but that breaking changes should be able to happen more frequently and within a manageable scope.
This also implies that we'll actively try to avoid dragging a major version on for many years, which has the the effect, that SFML 3 will end up rather short-lived compared to SFML 2.

Here's a rough roadmap what the goal is in the near future:

SFML 2.6 (see GitHub Project for details)

• Scan codes
• Required bug fixes
• Small championed contributions

SFML 3

Priority 1

• C++17
  
  • Move semantics
  • NonCopyable
  • unique_ptr
  • ...
• Deprecations

Priority 2

• Hot API discussion points (TBD)
• (Setup for multiple rendering backends)

Backports

We're generally open to backporting critical bug fixes to SFML 2, but it will be decided on a case-by-case basis and the focus should really be in moving forward.

Summary

The current roadmap moves SFML 3 from an infinitely far away horizon to the next version after SFML 2.6. Major versions don't require massive API evolutions, but it simply indicates a breaking change.

I'm interested in hearing what people think of this proposal, so let the discussion begin!
Keep in mind though, that the point of the discussion here, isn't necessarily about a single item on the list, but it should be more on the whole perspective change.

[Rosme]

Good idea this thread, thanks eXpl0it3r.

My first question is why C++14 for SFML 3.0? C++17 is already standard and is relatively well supported at this moment by every major compiler (according to this page). By the time SFML 3.0 will come out, it will definitely be supported.

Considering how many people seems to ask for filesystem support(and possibily other features), supporting C++17 directly solves that kind of problem, instead of having SFML implementing, only to deprecate it not long after (std::thread vs sf::thread comes to my mind about this). I would expect sf::Thread to be altogether removed anyway from SFML 3.0.

As for the setup for backends, I think it could be very interesting to discuss the possibility of doing such thing. Could also help to port it to more esoteric platform (Xone, PS4, Switch, etc.). I'm all for that, although I understand the work to do something like this can be quite huge.

Finally, while it's nice to add all the things mentions in the list to SFML 2.6, why not start focusing on SFML 3.0 directly for some of those? Scan codes are well advanced that it makes sense, but the rest could probably be more part of SFML 3.0 development directly, making the release of that version earlier than expected, which can only be appreciated.

[eXpl0it3r]

My first question is why C++14 for SFML 3.0? C++17 is already standard and is relatively well supported at this moment by every major compiler (according to this page). By the time SFML 3.0 will come out, it will definitely be supported.

Support and adoption are two separate things, but I generally agree that C++17 would provide some additional possibilities. I'd like to see the original C++ Standard discussion to be picked up and continued in its dedicated thread.

As for the setup for backends, I think it could be very interesting to discuss the possibility of doing such thing. Could also help to port it to more esoteric platform (Xone, PS4, Switch, etc.). I'm all for that, although I understand the work to do something like this can be quite huge.

It's certainly a discussion to be had and also check on a technical level what could be done.

Finally, while it's nice to add all the things mentions in the list to SFML 2.6, why not start focusing on SFML 3.0 directly for some of those? Scan codes are well advanced that it makes sense, but the rest could probably be more part of SFML 3.0 development directly, making the release of that version earlier than expected, which can only be appreciated.

There are already many things near completion for SFML 2.6 - if you check the GitHub Project you see that a lot of things are already in review/testing state or at least WIP.
Plus as I said the focus of SFML 3 should be to introduce C++14, clean up some baggage, but it shouldn't be focused on building many new features.

[Klaim]

Would it be ok to consider switching to using a dependency management tool for that version?
I'm thinking mainly about solving the issue of having binary dependencies inside the extlibs directory.

[eXpl0it3r]

In some endless discussion quite a while back it was decided to move the dependencies into its own repository, but in the end we never did it.

At this point no dependency manager has been well established in the C++ community, as such I don't think we should require one or the other flavor. However I think if we could do it transparently with CMake while you're building, it might be something to think about.

[Klaim]

Indeed at least separating them would help.

Using CMake apparently would work with recent versions but I didnt try (last time I used ExternalDependency module it failed quite spectacularly for my use case but it was a very complex use case). I know they made efforts in this direction but it's only available in last version(s).

I think at least separating the dependencies and listing the package names and versions somewhere in the root directory would be a good first step for the future of this project's dependenies management.
I guess I long as it's easy for beginner (one command to get everything), it should be fine.

[eXpl0it3r]

I updated the initial post with more recent information and further reduced the scope of SFML 2.6.

Additionally, I have been slowly making progress on the Scancode topic so we can close the last, big remaining feature for SFML 2.6.

[Nexus]

[Edit] Now that I think about it, this might as well be its own topic. Feel free to split, if you want to keep this thread focused on the high-level roadmap, without going into detail about C++ related API changes.



Maybe we should start discussing the bigger API changes, especially those that break existing code.
I'm just brainstorming here, so all I write is neither complete nor definitive.

Here's a good overview over new library and language features for all C++ standards.

Error Handling
It would be nice if resources could be returned from factories (named constructors), such as:

sf::Texture tex = sf::Texture::loadFromFile(...);
sf::Image img = sf::Image::loadFromMemory(...);

It would need to be discussed what to do in the error case.

• Exceptions: Nice to use in the happy path, but can be forgotten. Would require exception hierarchy and error discrimination/display mechanism. Requires exception safety everywhere.
• std::optional<T> -- Can be empty for failure, but there's no way to convey the error.
• std::variant<T, E> -- Either the type or an error. Like Rust's Result, but very unidiomatic to use in C++.
• sf::Result<T> or sf::Result<T, E> -- a simplified version of the above, tailored to SFML. Could have syntax sugar like * dereference.

Major removed APIs
Main candidate I see is sf::Thread.
With it come sf::ThreadLocal and sf::ThreadLocalPtr.

It can be discussed whether sf::Time is necessary given std::chrono, but the latter is very generic and can be overwhelming for the small amount of functionality that SFML needs. Interop (conversion from/to) should definitely be provided though.


Filesystem and path
C++17 Filesystem could benefit both public API and implementation.
If it's too tedious to construct strings to be used in place of std::filesystem::path, convenience overloads for sf::String or const char* can be offered.



Ownership and smart pointers
I can't think of a vast number of places where SFML would benefit from smart pointers, but I could imagine that std::unique_ptr and std::shared_ptr could clarify ownership semantics, when the library does not simply "borrow" (reference to) a user-created object, but (partially) own it.

std::unique_ptr in particular is a good abstraction boundary, when pointers to abstract base classes, such as sf::Drawable or sf::Shape have to be moved (ownership-transferred).

Apart from that, move semantics should be employed in the library, mainly for heavy resources.


New emerged idioms
Smaller things like:

• passing {x, y} for sf::Vector2 parameters, and subsequently a smaller number of constructors.
  
• If there are callback-like classes, instead of having an abstract base class with 1 method, we could use std::function. SFML doesn't use that a lot though.
  
• std::byte instead of char/void pointers.
  
• enum struct
  
• Lambda expressions mostly to simplify the implementation. As expressions, they have no direct use in the API.
• Range based for loops
• [[deprecated]] attribute
• nullptr everywhere, NULL should no longer be used
  
• std::optional for parameters and return types
  
• override, = default, = delete, and if absolutely needed final
  
  

Out of scope
I think we also have to be careful what not to include. In particular, we should not have the mindset "this feature is new, so we have to use it", but rather evaluate on a case-to-case basis, if a new C++ language/library feature actually fits in the scope.

Some things I'm thinking of that should be used with care:

• Type inference. auto is nice for iterators, but using it for ints and vectors may easily make code less readable. Same for inferred return types -- apart from readability and increased compile time, they can also introduce subtle bugs/breaking changes if a return expression changes type by accident.
  
• Template metaprogramming. Variadic templates, folding expressions, variable templates, and all the dark magic around it. If it allows something to be used much easier, why not, but it shouldn't be the primary API design tool  ;)
  
• Uniform initialization. This is the biggest misnomer and in my opinion one of the worst additions to the language. Instead of making anything uniform, now we're left with 4 (!!) syntaxes to initialize a variable, and new ambiguities (std::vector<int>{2, 3}) are introduced. A strict convention which syntaxes to use would solve this problem.
  
• constexpr and compile-time computations. Those are almost always optimizations, and thus should have low priority compared to more important features. We need to keep in mind that adding the keyword to a majority of the public API also has a readability/usability cost, possibly for a small number of users truly benefitting. It's different for cases where it's easy to add and can significantly improve performance in the general case.

[unlight]

This is a really good conversation starter Nexus! I have some thoughts in response..

Error Handling
I don't like the idea of having resources constructed through factory methods. Once we get move semantics implemented, you could implement your own factory methods that handle errors in what ever way you like. Forcing an error handling method would be an opinionated debate with no right or wrong answers.

Major removed APIs
I agree that sf::Thread has no place anymore, but totally support keeping sf::Time for the reduced verbosity. We could add an std::chrono::duration operator to the Time class so that it works natively with std::thread::sleep functions.


Ownership and smart pointers
I like the idea of using std::unique_ptr for handling object lifetimes inside SFML classes, but personally would prefer if SFML never forced the user to create a smart pointer to interact with the library. This is just personal preference, it would be good to hear what others thought.

[Nexus]

Error Handling
I don't like the idea of having resources constructed through factory methods. Once we get move semantics implemented, you could implement your own factory methods that handle errors in what ever way you like. Forcing an error handling method would be an opinionated debate with no right or wrong answers.

The library still has to provide this functionality. "Opinionated" in this sense mostly means "consistent" and "that's the recommended way of doing it".

Currently, this API is

sf::Texture texture;
if (!texture.loadFromFile(...))
{
    // error handling
}

and this is equally opinionated, but has several technical drawbacks: easy to forget checking the return type, no const variables, no way to get error message/code, unclear semantics when re-loading (and failing), dealing with invalid (unloaded) states, etc.

Of course it can be discussed if this would remain the best API for SFML 3, but keep in mind that the original reason to do it like this was because SFML doesn't use exceptions, so constructors cannot fail.

Constructors on the other hand are not a good idea, as they cannot specify the source (file, memory, stream...), and this would need to be dispatched solely based on parameter types. There would already be conflicts now, e.g. with sf::Shader.

Hence the suggested named constructor idiom (factory) -- it's an established idiom and shines especially in combination with move semantics.

[eXpl0it3r]

Some update on the current situation.

The scancode feature is very slowly being finalized, it's still planned for SFML 2.6.

As there's a high interest in getting the ball rolling for bringing C++17 to SFML and thus also starting off the development for SFML 3.

To achieve both of these goals, we created already a sort of release branch 2.6.x and will start development of SFML 3 on the master branch right now.

[eXpl0it3r]

Not sure where to place the best, so I'll just do it here for now.

We want to document breaking changes on the following wiki page: https://github.com/SFML/SFML/wiki/SD:-SFML-3:-Breaking-Changes

This doesn't have to be elaborate in anyway, but I believe it's simpler to collect this information as we go, than try and reconstruct it after the fact.
The goal for me would be to write a sort of upgrade guide before the SFML 3 release.

[KyraDigitalGames]

Looks good, but you should definitely plan smaller releases.

It is standard in game development to only use releases and not the master version. So we've been stuck on 2.5.1 for 4 years.

[Nexus]

Looks good, but you should definitely plan smaller releases.

Generally I agree, during "stable" times this is the way to go and we have neglected this to some extent.

During a huge breaking change however (SFML 3), many small releases directly conflict with Semver, which is also good industry practice. I know that many libraries don't care about this, and it makes everyone's life harder and is one big reason why dependency management is such a mess in C++ (another reason being lack of standard tooling).

If we had released during the SFML 2->3 period, we would have had two options:

• Stay true to Semver and release a major version many times for small changes. This would quickly turn our versioning schema into a meme.
• Don't care about Semver after we've taken it pretty seriously for the entirety of SFML 2. This would not only send a questionable message, but might also ruin the day of many developers going into SFML 3 with the same stability expectations as they had previously.

At the end of the day, both groups are faced with several iterations of breaking changes, just to maintain feature parity. Sometimes we might even revert previous changes. I'm not sure this is what we want.

When game developers prefer outdated releases over Git versions due to policies, that's a reasonable strategy when it comes to minimize the number of code adaptations (at the cost of one bigger change taking more time). But it's ultimately their decision, they are free to use an in-development version to benefit from cutting edge changes (at the risk of bugs and API changes). So everyone can choose a trade-off acceptable to them.

TLDR: it's a matter of communication -- I think the current model makes it relatively clear that the Git version is "in flux" while releases are stable.

[MetalCoder]

I hope its okay if I ask this, but will SFML 2.6 have a C port release? I see that SFML 2.6 is getting very close to being released.