Stats

Basic hyper repo stats
16
7,920
8.4
4 days ago

hyperium/hyper is an open source project licensed under MIT License which is an OSI approved license.

Hyper Alternatives

Similar projects and alternatives to hyper

  • GitHub repo rust

    Empowering everyone to build reliable and efficient software.

  • GitHub repo warp

    A super-easy, composable, web server framework for warp speeds.

  • GitHub repo rfcs

    RFCs for changes to Rust

  • GitHub repo tokio

    A runtime for writing reliable asynchronous applications with Rust. Provides I/O, networking, scheduling, timers, ...

  • GitHub repo reqwest

    An easy and powerful Rust HTTP Client

  • GitHub repo async-std

    Async version of the Rust standard library

  • GitHub repo rustls

    A modern TLS library in Rust

  • GitHub repo rust-cross

    Everything you need to know about cross compiling Rust programs!

  • GitHub repo ureq

    Minimal request library in rust.

  • GitHub repo webpki

    WebPKI X.509 Certificate Validation in Rust

  • GitHub repo superrecord

    Haskell: Supercharged anonymous records (by agrafix)

  • GitHub repo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • GitHub repo Electron

    :electron: Build cross-platform desktop apps with JavaScript, HTML, and CSS

  • GitHub repo Ansible

    Ansible is a radically simple IT automation platform that makes your applications and systems easier to deploy and maintain. Automate everything from code deployment to network configuration to cloud management, in a language that approaches plain English, using SSH, with no agents to install on remote systems. https://docs.ansible.com.

  • GitHub repo Scrapy

    Scrapy, a fast high-level web crawling & scraping framework for Python.

  • GitHub repo Babel (Formerly 6to5)

    🐠 Babel is a compiler for writing next generation JavaScript.

  • GitHub repo Pandas

    Flexible and powerful data analysis / manipulation library for Python, providing labeled data structures similar to R data.frame objects, statistical functions, and much more

  • GitHub repo matplotlib

    matplotlib: plotting with Python

  • GitHub repo pytest

    The pytest framework makes it easy to write small tests, yet scales to support complex functional testing

  • GitHub repo JRuby

    JRuby, an implementation of Ruby on the JVM

NOTE: The number of mentions on this list indicates mentions on common posts. Hence, a higher number means a better hyper alternative or higher similarity.

Posts

Posts where hyper has been mentioned. We have used some of these posts to build our list of alternatives and similar projects - the last one was on 2021-04-20.
  • Preparing Rustls for Wider Adoption
    news.ycombinator.com | 2021-04-20
  • Hey Rustaceans! Got an easy question? Ask here (15/2021)!
    reddit.com/r/rust | 2021-04-12
    1: Seems simple enough to me, depending on how low you want to go.
  • Why asynchronous Rust doesn't work
    news.ycombinator.com | 2021-03-09
    I've jumped on the Rust bandwagon as part of ZeroTier 2.0 (not rewriting its core, but rewriting some service stuff in Rust and considering the core eventually). I've used a bit of async and while it's not as easy as Go (nothing is!) it's pretty damn ingenious for a systems programming language.

    Ownership semantics are hairy in Rust and require some forethought, but that's also true in C and C++ and in those languages if you get it wrong there you just blow your foot off. Rust instead tells you that the footgun is dangerously close to going off and more or less prohibits you from doing really dangerous things.

    My opinion on Rust async is that it its warts are as much the fault of libraries as they are of the language itself. Async libraries are overly clever, falling into the trap of favoring code brevity over code clarity. I would rather have them force me to write just a little more boilerplate but have a clearer idea of what's going on than to rely on magic voodoo closure tricks like:

    https://github.com/hyperium/hyper/issues/2446

    I'd rather have seen this implemented with traits and interfaces. Yes it would force me to write something like a "factory," but I would have spent 30 minutes doing that instead of three hours figuring out how the fuck make_service_fn() and service_fn() are supposed to be used and how to get a f'ing Arc<> in there.

    Oh, and Arc<> gets around a lot of issues in Rust. It's not as zero-cost as Rc<> and Box<> and friends but the cost is really low. While async workers are not threads, it can make things easier to treat them that way and use Arc<> with them (as long as you avoid cyclic structures). So if async ownership is really giving you headaches try chickening out and using Arc<>. It costs very very little CPU/RAM and if it saves you hours of coding it's worth it.

    Oh, and to remind people: this is a systems language designed to replace C/C++, not a higher level language, and I don't expect it to ever be as simple and productive as Go or as YOLO as JavaScript. I love Go too but it's not a systems language and it imposes costs and constraints that are really problematic when trying to write (in my case) a network virtualization service that's shooting (in v2.0) for tens of gigabits performance on big machines.

  • Rust as a Flask API replacement? + performance benefits?
    reddit.com/r/rust | 2021-03-01
    that's interesting. What did you use for your web server? I know there's a chapter about it in the book, I haven't got so far yet, was it that one you used?.. I did found this software called Hyper that claims to be very fast and "correct" and I personally rather rely on other's people software that's much more robust than me writing my own as a beginner (tho I assume it is a good learning experience actually). https://github.com/hyperium/hyper
  • Rust and C++ comparisons
    reddit.com/r/rust | 2021-02-28
    Rust's borrow checker also enables a very solid implementation of the typestate pattern, which is how the Hyper HTTP library is able to catch invalid use of the HTTP protocol at compile time. (The typestate pattern lets you enforce correct finite state machine traversal at compile time, and protocols like HTTP can be represented as finite state machines.)
  • Closest GC language to Rust?
    reddit.com/r/rust | 2021-02-24
    It's what allows https://hyper.rs/ to catch "Tried to set an HTTP header after the body began streaming" at compile time. (An example I like to use because so many people have seen the PHP error for that at least once.)
  • James W. Heisig's Remembering the Kanji (RTK) – Review of the first book (2200 kanji)
    The whole thing is actually pretty simple technology-wise, and there isn't that much to it. It's written in Rust, with my own web framework based on hyper, a simple custom templating engine, and no database. (I just use the filesystem as a database, and keep a lot of stuff in memory.)
  • Actix or Warp?
    reddit.com/r/rust | 2021-02-21
    As memory safety is an important priority, choose warp for more safety guarantee (it's built on top of hyper which is fast, correct and production-ready). Although, worth pointing out that most of the UB bugs have been resolved in actix-web as of now.
  • Is OpenBSD actually slow or inefficient?
    reddit.com/r/openbsd | 2021-02-14
    When I was checking out 6.8 on my X1 Carbob Gen8 with Core i5, I tried to do a clean build of hyper, since I compile Rust a lot, at it took ~47 seconds on OpenBSD (after tweaking login class, thread limits and so on, but I didn't touch hyperthreading settings). In comparison, it took ~21 second on Fedora 33.
  • Compilation failure: Method not found on struct when crate included by local path
    reddit.com/r/rust | 2021-02-10
    As for the use-case for doing this: I am investigating a hyper issue 2419 and I wanted add some more debug/trace prints.
  • Haskell ghost knowledge; difficult to access, not written down
    reddit.com/r/haskell | 2021-01-24
    Initial PR to expose a C API for hyper (for usage in a curl backend): https://github.com/hyperium/hyper/pull/2278
  • Announcing hyper v0.14!
    reddit.com/r/rust | 2020-12-23
    This issue looks, as if hyper is still easily attachable: https://github.com/hyperium/hyper/issues/2355
  • Tokio, the async runtime for Rust, hits 1.0
    news.ycombinator.com | 2020-12-23
    Can't find async-std feature here: https://github.com/hyperium/hyper/blob/master/Cargo.toml

    do you have an example?

    Either way, "can be configured" means that custom code for each runtime must be written, it is not like lets say "Futures", which can be used generically.

  • Announcing Tokio 1.0
    reddit.com/r/rust | 2020-12-23
    hyper 0.14 will be released any time now (https://github.com/hyperium/hyper/pull/2369 was just merged)
  • Linkerd: Service Mesh Overview
    dev.to | 2020-11-18
    Hyper - https://github.com/hyperium/hyper