ads

Friday, April 5, 2024

Show HN: Left Nvidia to build an AI Investing Copilot. [Need Feedback] https://ift.tt/BbyxQDw

Show HN: Left Nvidia to build an AI Investing Copilot. [Need Feedback] https://rafa.ai/ April 6, 2024 at 01:49AM

Show HN: Fancy-ANSI – Small JavaScript library for converting ANSI to HTML https://ift.tt/MEJI5Kr

Show HN: Fancy-ANSI – Small JavaScript library for converting ANSI to HTML I made this tool to add support for custom ANSI palettes to kubetail ( https://ift.tt/mKHzlqu ). Maybe you'll find it useful too. Let me know if you have any suggestions! https://ift.tt/Bpm16FW April 3, 2024 at 03:46PM

Thursday, April 4, 2024

Show HN: FizzBee – Formal methods in Python – Easiest Lang for everyday use https://ift.tt/TBle7HZ

Show HN: FizzBee – Formal methods in Python – Easiest Lang for everyday use GitHub: https://ift.tt/5NEv4nB Traditionally, formal methods are used only for highly mission critical systems to validate the software will work as expected before it's built. Recently, every major cloud vendor like AWS, Azure, Mongo DB, confluent, elastic and so on use formal methods to validate their design like the replication algorithm or various protocols doesn't have a design bug. I used TLA+ for billing and usage based metering applications. However, the current formal methods solutions like TLA+, Alloy or P and so on are incredibly complex to learn and use, that even in these companies only a few actually use. Now, instead of using an unfamiliar complicated language, I built formal methods model checker that just uses Python. That way, any software engineer can quickly get started and use. I've also created an online playground so you can try it without having to install on your machine. In addition to model checking like TLA+/PlusCal, Alloy, etc, FizzBee also has performance and probabilistic model checking that be few other formal methods tool does. (PRISM for example, but it's language is even more complicated to use) Please let me know your feedback. Url: https://FizzBee.io Git: https://ift.tt/5NEv4nB https://fizzbee.io/ April 2, 2024 at 05:45PM

Show HN: Managed GitHub Actions Runners for AWS https://ift.tt/6ZSuW4c

Show HN: Managed GitHub Actions Runners for AWS Hey HN! I'm Jacob, one of the founders of Depot ( https://depot.dev ), a build service for Docker images, and I'm excited to show what we’ve been working on for the past few months: run GitHub Actions jobs in AWS, orchestrated by Depot! Here's a video demo: https://www.youtube.com/watch?v=VX5Z-k1mGc8 , and here’s our blog post: https://ift.tt/muBjrQ5 . While GitHub Actions is one of the most prevalent CI providers, Actions is slow, for a few reasons: GitHub uses underpowered CPUs, network throughput for cache and the internet at large is capped at 1 Gbps, and total cache storage is limited to 10GB per repo. It is also rather expensive for runners with more than 2 CPUs, and larger runners frequently take a long time to start running jobs. Depot-managed runners solve this! Rather than your CI jobs running on GitHub's slow compute, Depot routes those same jobs to fast EC2 instances. And not only is this faster, it’s also 1/2 the cost of GitHub Actions! We do this by launching a dedicated instance for each job, registering that instance as a self-hosted Actions runner in your GitHub organization, then terminating the instance when the job is finished. Using AWS as the compute provider has a few advantages: - CPUs are typically 30%+ more performant than alternatives (the m7a instance type). - Each instance has high-throughput networking of up to 12.5 Gbps, hosted in us-east-1, so interacting with artifacts, cache, container registries, or the internet at large is quick. - Each instance has a public IPv4 address, so it does not share rate limits with anyone else. We integrated the runners with the distributed cache system (backed by S3 and Ceph) that we use for Docker build cache, so jobs automatically save / restore cache from this cache system, with speeds of up to 1 GB/s, and without the default 10 GB per repo limit. Building this was a fun challenge; some matrix workflows start 40+ jobs at once, then requiring 40 EC2 instances to launch at once. We’ve effectively gotten very good at starting EC2 instances with a "warm pool" system which allows us to prepare many EC2 instances to run a job, stop them, then resize and start them when an actual job request arrives, to keep job queue times around 5 seconds. We're using a homegrown orchestration system, as alternatives like autoscaling groups or Kubernetes weren't fast or secure enough. There are three alternatives to our managed runners currently: 1. GitHub offers larger runners: these have more CPUs, but still have slow network and cache. Depot runners are also 1/2 the cost per minute of GitHub's runners. 2. You can self-host the Actions runner on your own compute: this requires ongoing maintenance, and it can be difficult to ensure that the runner image or container matches GitHub's. 3. There are other companies offering hosted GitHub Actions runners, though they frequently use cheaper compute hosting providers that are bottlenecked on network throughput or geography. Any feedback is very welcome! You can sign up at https://ift.tt/w1WmEKL for a free trial if you'd like to try it out on your own workflows. We aren't able to offer a trial without a signup gate, both because using it requires installing a GitHub app, and we're offering build compute, so we need some way to keep out the cryptominers :) April 4, 2024 at 09:32PM

Show HN: DotLottie Player – A New Universal Lottie Player Built with Rust https://ift.tt/xVKsb0z

Show HN: DotLottie Player – A New Universal Lottie Player Built with Rust Hi HN, For the past few months we’ve been building dotlottie-rs, a new Lottie and dotLottie player that aims to run everywhere with smooth, high frame rate rendering and guarantee visual and feature support consistency across a large number of platforms and device types. It is lightweight, has low resource requirements and is performant. It is MIT-licensed and is available at: https://ift.tt/tCqX8uN The player is written in Rust and uses a minimal number of external dependencies. We utilize uniffi-rs to generate FFI bindings for Kotlin, Swift, and WASM, which are then used in our platform native distributions for Android, iOS and Web while maintaining a consistent API and experience across them. We also provide distributions for React and Vue to make it easy to adopt in many existing web projects. The player is also ideal for use in backend systems and pipelines for high performance server-side rendering of Lottie/dotLottie, and can be used easily in NodeJS projects. The player is named dotlottie-rs because, apart from the first class Lottie support, we aim to have first class support for dotLottie ( https://ift.tt/KlfMbXJ ), a superset of Lottie we developed that builds on Lottie to add enhanced features like multi-animation support, improved resource bundling, theming, state machines and interactivity (latter two are currently in development). Under the hood, the player uses the open-source, lightweight, high performance ThorVG library ( https://www.thorvg.org/ ) for vector graphics and Lottie rendering, supporting software, OpenGL, and WebGPU (currently in beta) rasterization backends. We are working towards landing complete support of the Lottie format spec ( https://ift.tt/TiX1ghv ) as soon as possible. We are starting to test and deploy it across our platform and hope it helps achieve similar improvements in performance and support as we are seeing! There’s a few demos: Rust project: https://ift.tt/9Fg35ca... Web: https://ift.tt/4G7ipBI... Would love to hear your thoughts and feedback :) https://ift.tt/tCqX8uN April 4, 2024 at 08:59PM

Wednesday, April 3, 2024

Show HN: I've built a locally running perplexity clone https://ift.tt/ECdVke9

Show HN: I've built a locally running perplexity clone The video demo runs a 7b Model on a normal gaming GPU. I think it already works quite well (accounting for the limited hardware power). :) https://ift.tt/zFeaJ8o April 4, 2024 at 04:27AM

Show HN: Burr – A framework for building and debugging GenAI apps faster https://ift.tt/HQYvLD0

Show HN: Burr – A framework for building and debugging GenAI apps faster Hey HN, we're developing Burr (github.com/dagworks-inc/burr), an open-source python framework that makes it easier to build and debug GenAI applications. Burr is a lightweight library that can integrate with your favorite tools and comes with a debugging UI. If you prefer a video introduction, you can watch me build a chatbot here: https://www.youtube.com/watch?v=rEZ4oDN0GdU . Common friction points we’ve seen with GenAI applications include logically modeling application flow, debugging and recreating error cases, and curating data for testing/evaluation (see https://ift.tt/e1U7pwF ). Burr aims to make these easier. You can run Burr locally – see instructions in the repo. We talked to many companies about the pains they felt in building applications on top of LLMs and were surprised how many built bespoke state management layers and used printlines to debug. We found that everyone wanted the ability to pull up the state of an application at a given point, poke at it to debug/tweak code, and use for later testing/evaluation. People integrating with LLMOps tools fared slightly better, but these tend to focus solely on API calls to test & evaluate prompts, and left the problem of logically modeling/checkpointing unsolved. Having platform tooling backgrounds, we felt that a good abstraction would help improve the experience. These problems all got easier to think about when we modeled applications a state machines composed of “actions” designed for introspection (for more read https://ift.tt/eMWKqbo... ). We don’t want to limit what people can write, but we do want to constrain it just enough that the framework provides value and doesn’t get in the way. This led us to design Burr with the following core functionalities: 1. BYOF. Burr allows you to bring your own frameworks/delegate to any python code, like LangChain, LlamaIndex, Hamilton, etc. inside of “actions”. This provides you with the flexibility to mix and match so you’re not limited. 2. Pluggability. Burr comes with APIs to allow you to save/load (i.e. checkpoint) application state, run custom code before/after action execution, and add in your own telemetry provider (e.g. langfuse, datadog, DAGWorks, etc.). 3. UI. Burr comes with its own UI (following the python batteries included ethos) that you can run locally, with the intent to connect with your development/debugging workflow. You can see your application as it progresses and inspect its state at any given point. The above functionalities lend themselves well to building many types of applications quickly and flexibly using the tools you want. E.g. conversational RAG bots, text based games, human in the loop workflows, text to SQL bots, etc. Start with LangChain and then easily transition to your custom code or another framework without having to rewrite much of your application. Side note: we also see Burr as useful outside of interactive GenAI/LLMs applications, e.g. building hyper-parameter optimization routines for chunking and embeddings & orchestrating simulations. We have a swath of improvements planned. We would love feedback, contributions, & help prioritizing. Typescript support, more ergonomic UX + APIs for annotation and test/eval curation, as well as integrations with common telemetry frameworks and capture of finer grained information from frameworks like LangChain, LlamaIndex, Hamilton, etc… Re: the name Burr, you may recognize us as the authors of Hamilton (github.com/dagworks-inc/hamilton), named after Alexander Hamilton (the creator of the federal reserve). While Aaron Burr killed him in a duel, we see Burr being a complement, rather than killer to Hamilton ! That’s all for now. Please don’t hesitate to open github issues/discussions or join our discord https://ift.tt/YHjT6QJ to chat with us there. We’re still very early and would love to get your feedback! https://ift.tt/FebXKHw April 3, 2024 at 08:42PM

Show HN: Portr – open-source ngrok alternative designed for teams https://ift.tt/mRTKvUZ

Show HN: Portr – open-source ngrok alternative designed for teams https://ift.tt/YZIpngb April 3, 2024 at 10:01AM

Tuesday, April 2, 2024

Show HN: HyperDX Local – Open-source Datadog alternative for local debugging/dev https://ift.tt/V0hnwBy

Show HN: HyperDX Local – Open-source Datadog alternative for local debugging/dev Hi HN, Mike and Warren here! We’ve been building an open source local-dev-friendly mode for HyperDX (hyperdx.io). It's a single Docker container that lets you view logs, metrics, and traces for local development in a similar way you can use them for production (live tail, filter/correlate logs & spans, build charts, flamegraph, etc.) Basically, imagine you can run Datadog in a single container for local development. We does this by spinning up an OpenTelemetry collector, Clickhouse DB and HyperDX UI all in a single container - it only takes a few seconds to start and lets you start live tailing your local logs and traces immediately (and graph metrics of course). README (w/ demo gif): https://ift.tt/G7tSnZ5 We started building local mode as it became one of our most loved [1] community issue after sharing HyperDX. It made sense - as we constantly use HyperDX to debug our own issues locally, and have found it to be a huge productivity boost for things like… 1. Tailing multiple container logs (and grepping/isolating them) without a ton of different terminal splits open at the same time. 2. Be able to sensibly view structured logs and correlated traces to debug local issues (because you’re using structured logging and tracing right?) instead of adding ad-hoc console statements that print out exactly what I could’ve gotten from tracing. 3. Testing telemetry are actually emitting/correlating as expected, before shipping it all the way out to prod and realizing I accidentally created a very expensive high-cardinality metric or a span that has the wrong properties. We spent some time packaging & tuning our existing OSS stack to run in a single container with less memory/space requirements by staring at `dive` to slim down the image and applied incantations from documentation until memory usage improved. Additionally we removed a few non-local-friendly things like authentication requirements and extraneous services. It still has all the goodness you’d want - so you can full text search your logs/traces, live tail all your events, view spans correlated with logs (and vice versa), create dashboards based on logs, metrics, traces, and is fully OpenTelemetry compatible - just point your Otel SDK/collector to http://localhost:4318 (or 4317 for the grpc folks) and you’re already good to go. I’m excited to share what we’ve been working on and would love to hear your feedback and opinions! Spin up the container yourself to try it out: docker run -p 8000:8000 -p 4318:4318 -p 4317:4317 -p 8080:8080 -p 8002:8002 hyperdx/hyperdx-local Main Open Source Repo: https://ift.tt/dutnBLj Hosted Demo (in case you want to play around in a cloud sandbox instead): https://ift.tt/PuZTw45 HyperDX Landing Page: https://hyperdx.io [1]: https://ift.tt/OHY4y7X https://ift.tt/G7tSnZ5 April 2, 2024 at 10:49PM

Show HN: I built a search engine for 200k open source icons https://ift.tt/SDNFu6U

Show HN: I built a search engine for 200k open source icons https://iconbuddy.com/ April 2, 2024 at 11:17PM

Monday, April 1, 2024