sip VS str0m

Compare sip vs str0m and see what are their differences.

sip

SIP to WebRTC bridge for LiveKit (by livekit)

str0m

A Sans I/O WebRTC implementation in Rust. (by algesten)
InfluxDB - Power Real-Time Data Analytics at Scale
Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.
www.influxdata.com
featured
SaaSHub - Software Alternatives and Reviews
SaaSHub helps you find the best software and product alternatives
www.saashub.com
featured
sip str0m
1 13
70 287
- -
8.9 9.6
7 days ago 4 days ago
Go Rust
- MIT License
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.

sip

Posts with mentions or reviews of sip. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2024-01-04.

str0m

Posts with mentions or reviews of str0m. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2024-07-09.
  • Show HN: 30ms latency screen sharing in Rust
    8 projects | news.ycombinator.com | 9 Jul 2024
    Yep! It glues ffmpeg, str0m[0] and SDL together. I hope bitwhip doesn’t need to exist someday. When WHIP/WHEP has enough traction it will be easier to land in FFMPEG

    [0] https://github.com/algesten/str0m

  • Sans-IO: The secret to effective Rust for network services
    6 projects | news.ycombinator.com | 3 Jul 2024
    > To "time-out" in sans-IO style means that your state machine has an `Instant` internally and, once called at a specific point in the future, compares the provided `now` parameter with the internal timeout and changes its state accordingly. See [0] for an example.

    This part of the post was clear -- I didn't ask any clarifications about that, my point was about what I see as "read or timeout", a reasonable functionality to expose as a external facing function.

    The question is still "If I want to read or timeout, from inside a function I expose in a library that uses sans-IO style, how do I do that?".

    It seems like the answer is "if you want to accomplish read or timeout at the library function level, you either busy wait or pull in an async runtime, but whatever calls your state machine has to take care of that at a higher level".

    You see how this doesn't really work for me? Now I have to decide if my read_or_timeout() function exposed is either the default sync (and I have to figure out how long to wait, etc), or async.

    It seems in sans-IO style read_or_timeout() would be sync, and do the necessary synchronous waiting internally, without the benefit of being able to run other tasks from unrelated state machines in the meantime.

    > That entire `main` function is _not_ what you would expose as a library.

    Disagree -- it's entirely reasonable to expose "read your public IP via STUN" as a library function. I think we can agree to disagree here.

    > The event loop should always live as high up in the stack as possible, thereby deferring the use of blocking or non-blocking IO and allowing composition with other sans-IO components.

    Sure... but that means the code you showed me should never be made into a library (we can agree to disagree there), and I think it's reasonable functionality for a library...

    What am I missing here? From unrelated code, I want to call `get_ip_via_stun_or_timeout(hostnames: &[String], timeout: Duration) -> Option`, is what I'm missing that I need to wrap this state machine in another to pass it up to the level above? That I need to essentially move the who-must-implement-the-event-loop one level up?

    > You can absolutely write an event loop without async. You can set the read-timeout of the socket to the value of `poll_timeout() - Instant::now` and call `handle_timeout` in case your `UdpSocket::recv` call errors with a timeout. str0m has an example [1] like that in their repository.

    Didn't say you couldn't!

    What you've described is looping with a operation-supported timeout, which requires timeout integration at the function call level below you to return control. I get that this is a potential solution (I mentioned it in my edits on the first comment), but not mentioning it in the article was surprising to me.

    The code I was expecting to find in that example is like the bit in strom:

    https://github.com/algesten/str0m/blob/5b100e8a675cd8838cdd8...

    Clearly (IMO evidenced by the article using this method), the most ergonomic way to do that is with a tokio::select, and that's what I would reach for as well -- but I thought a major point was to do it sans IO (where "IO" here basically means "async runtime").

    Want to note again, this is not to do with the state machine (it's clear how you would use a passed in Instant to short circuit), but more about the implications of abstracting the use of the state machine.

    > All the event loops you see in the post are solely there to ensure we have a working program but are otherwise irrelevant, esp. implementation details like using `tokio::select` and the like. Perhaps I should have made that clearer.

    I personally think it exposes a downside of this method -- while I'm not a fan of simply opting in to either async (and whichever runtime smol/tokio/async-std/etc) or sync, what it seems like this pattern will force me to:

    - Write all code as sync

  • VoRS: Vo(IP) Simple Alternative to Mumble
    15 projects | news.ycombinator.com | 19 Apr 2024
  • Interview with Mo Rajabi, co-founder and CEO of Noor
    3 projects | dev.to | 18 Apr 2024
    In the video, Mo talked about a few packages like Cidre and StrOm, and we referred to SpaceDrive.
  • Is Something Bugging You?
    10 projects | news.ycombinator.com | 13 Feb 2024
    - Dropbox [3] uses a similar approach but they talk about it a bit more abstractly.

    Sans-IO is more documented in Python [4], but str0m [5] and quinn-proto [6] are the best examples in Rust I’m aware of. Note that sans-IO is orthogonal to deterministic test frameworks, but it composes well with them.

    With the disclaimer that my opinions are mine and mine alone, and don’t reflect the company I work at —— I do work at a rust shop that has utilized these techniques on some projects.

    TigerBeetle is an amazing example and I’ve looked at it before! They are really the best example of this approach outside of FoundationDB I think.

    [0]: https://risingwave.com/blog/deterministic-simulation-a-new-e...

    [1]: https://risingwave.com/blog/applying-deterministic-simulatio...

    [2]: https://dropbox.tech/infrastructure/-testing-our-new-sync-en...

    [3]: https://github.com/spacejam/sled

    [4]: https://fractalideas.com/blog/sans-io-when-rubber-meets-road...

    [5]: https://github.com/algesten/str0m

    [6]: https://docs.rs/quinn-proto/0.10.6/quinn_proto/struct.Connec...

  • Pure C WebRTC
    12 projects | news.ycombinator.com | 7 Jan 2024
    I am really excited about https://github.com/sepfy/libpeer. It has examples ready for ESP32 etc....

    When working on KVS I wasn't familiar with the embedded space at all. I saw 'heavyweight' embedded where you were running on Linux. Then you had RTOS/No OS at all. I wasn't prepared for these devices at all. If we can make WebRTC work in the embedded space I think it will really accelerate what developers are able to build!

    Remotely driven cars, security cameras, robots in hospitals that bring iPads to infectious patients etc... Creative people are building amazing things. The WebRTC/video space needs to work harder and support them :)

    -----

    I love how diverse the WebRTC space is now. Outside of this implementation you have plenty of other options!

    * https://github.com/shinyoshiaki/werift-webrtc (Typescript)

    * https://github.com/pion/webrtc (Golang)

    * https://github.com/webrtc-rs/webrtc (Rust)

    * https://github.com/algesten/str0m (Rust)

    * hhttps://github.com/sepfy/libpeer (C/Embedded)

    * https://webrtc.googlesource.com/src/ (C++)

    * https://github.com/sipsorcery-org/sipsorcery (C#)

    * https://github.com/paullouisageneau/libdatachannel (C++)

    * https://github.com/elixir-webrtc (Elixir)

    * https://github.com/aiortc/aiortc (Python)

    * GStreamer’s webrtcbin (C)

    See https://github.com/sipsorcery/webrtc-echoes for examples of some running against each other.

  • WebRTC for the Curious
    18 projects | news.ycombinator.com | 4 Jan 2024
  • Show HN: Bring phone calls into the browser (sip-to-WebRTC)
    9 projects | news.ycombinator.com | 4 Jan 2024
  • WebRTC support being added to FFmpeg
    6 projects | news.ycombinator.com | 30 May 2023
  • str0m 0.1.0 – Sans-IO WebRTC library
    1 project | /r/rust | 17 Mar 2023
    Find it here: crates.io/crates/str0m Code here: github.com/algesten/str0m Docs here: docs.rs/str0m/0.1.0/str0m/

What are some alternatives?

When comparing sip and str0m you can also consider the following projects:

ffmpeg - FFmpeg Zig package

broadcast-box - A broadcast, in a box.

go2rtc - Ultimate camera streaming application with support RTSP, RTMP, HTTP-FLV, WebRTC, MSE, HLS, MP4, MJPEG, HomeKit, FFmpeg, etc.

webrtc-echoes - Simple useful interoperability tests for WebRTC libraries. If you are a WebRTC library developer we'd love to include you!

webrtc - A pure Rust implementation of WebRTC

ffmpeg-webrtc - Support WebRTC(WHIP) for FFmpeg.

libpeer - WebRTC Library for IoT/Embedded Device using C

quinn - Async-friendly QUIC implementation in Rust

SIPSorcery - A WebRTC, SIP and VoIP library for C# and .NET. Designed for real-time communications apps.

libdatachannel - C/C++ WebRTC network library featuring Data Channels, Media Transport, and WebSockets

webrtc-for-the-curious - WebRTC for the Curious: Go beyond the APIs

InfluxDB - Power Real-Time Data Analytics at Scale
Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.
www.influxdata.com
featured
SaaSHub - Software Alternatives and Reviews
SaaSHub helps you find the best software and product alternatives
www.saashub.com
featured

Did you konow that Go is
the 4th most popular programming language
based on number of metions?