The recent global pandemic has affected society, globally, all the way down to our personal lives with friends and family.
The workplace is obviously not immune to the disruptive effects of reduced travel and impeded personal contacts, and as we know all too well, now more than ever we rely on collaboration tools to get work done.
Now the question is: are our enterprise tools fit for purpose and ready to support us in this new “normal” remote-collaboration?
We at Masters of Pie think that collaboration tools should be better: while some isolated software helps out in specific use cases such as conferencing and assembling specific types of documents, we pose the following question: why isn’t all the software we use just collaborative out of the box? It seems to us that collaborative features are a fundamental requirement for any software at this point in time.
And this is exactly the task we set ourselves to tackle with Radical SDK v4 (Pumpkin Pie): we re-thought Radical to be able to turn any enterprise software into collaborative software.
Blue chip companies with complex software (CAD, PLM and BIM) and a need to support the growing collaborative requirements in the “new normal”. With Radical being a pure whitelabel SDK you can extend your software with enterprise collaborative features in lightning quick time.
Companies who have built single user clients with Unity, Unreal or other 3D engines but need enterprise grade networking for these clients. With the Radical 4.0 SDK Pumpkin Pie release you can very easily add out the box collaboration to your clients. We run through a Unity example below.
Radical is now used by industry leading software providers like Siemens and has been built from the ground up to provide robust, secure enterprise grade tools to build your own real-time collaborative products.
Universal Command Sharing
Radical 4.0 provides what we like to term Universal Command Sharing. This enables software packages (like Siemens NX or Unity3D) to share commands across the network, securely and easily using our API.
A common request we hear from automotive designers is that they would often have ad-hoc design reviews with other designers or often other departments. Traditionally this would all happen onsite and was quick and responsive.
Now with forced remote working these designers want their digital design tools to be collaborative. With command sharing we are able to make this happen. Any changes that appear on one software client can be shared via our Radical server and pushed into the other client application. Keeping everyone in sync with changes in real-time.
This is a high-level example of how Radical is able to integrate natively to add value to your existing Enterprise software products. Below we dig deeper into the SDK.
How does the SDK work and what does it do?
Simply put, our SDK provides your enterprise software with two additional parts: a runtime that integrates very easily into your client and a server that can be deployed anywhere, either on the cloud or on-premise.
The Radical SDK Pumpkin Pie release release unlocks collaboration for any software, given a small integration effort. How do we achieve this?
The SDK complements your existing software and gives developers a simple way to create synchronised clients and servers. To do this you create a repository using the Radical API that stores references to your software clients objects like meshes, models or camera positions etc. These Radical objects in the repository (that reference your own client objects) can then be very easily synchronised from one client to the next using our server. You do not need to worry about synchronising objects across the network as Radical handles that all for you.
Radical is a lightweight SDK designed to complement your own software clients and meet your collaboration goals. It is built in .Net Standard 2.0, as such it is widely compatible with the .Net ecosystem, an updated table of what is supported can be found in the Microsoft Documentation. Other details below:
- Windows/Mac/Linux native support
- .Net Framework/Core/Standard support
- C++ support via interop
Radical happily runs either as its own process or in a thread. As a separate process you can use whatever communication protocol you see fit, be it shared memory or UDP for example. As a lightweight library, Radical can run in the same thread allowing rapid communication with your own applications.
“Universal command sharing” in practice: a case study
To test the practical usefulness of the Radical SDK, we decided to showcase how time consuming it would be to add “collaboration” to a typical software package of sizable complexity. Hence, we decided to add collaboration to a popular real-time development platform: Unity3D.
The Unity3D + Radical solution works as follows: the SDK is used to create both a “runtime” (that communicates with Unity via UDP) and a “collaboration server” that runs on a small AWS instance. The runtime integration enriches Unity3D with the ability to connect to a Radical session, while the “collaboration server” creates and maintains the collaborative session and synchronises the state of all the clients. Note that Unity clients can join the session “at any time”. Radical effectively mirrors (and synchronises) all the Unity objects into its own repository that continues a list of Radical objects, handling all the exception cases.
The total time to complete this integration was 10 man-days of development. Regardless of the exact number of man-days, the key takeaway from this exercise was that we could add collaboration to an enterprise software client of significant complexity in days rather than months.
As the server is purpose built for secure, enterprise environments you can roll out stable collaborative products to your enterprise users very rapidly, meeting the needs of your remote users and teams.
Masters of Pie believe that the Radical Release 4.0 of the SDK will significantly change the time and cost equation of “adding collaboration”: as per the example, a deliverable coming under the 10 days threshold means that a single developer using the Radical SDK can make any software “collaborative” in “just one sprint”, bringing the cost, risk, and planning effort well within the grasp of most enterprise projects – even small ones.