Show HN: Tabby – A self-hosted GitHub Copilot (github.com)

[1]: https://github.com/TabbyML/tabby/blob/main/tabby/tools/repos...

[2]: https://github.com/TabbyML/tabby/blob/main/tabby/tools/train...

[0] https://codeium.com/

Is it writing meaningful code for me? Nah. Is it helpful? Certainly.

It costs 10$/month and probably saves me hours in stupid boilerplate, not just because it reduces typing but because the kind of typing it fixes is the boring stuff that gets me out of flow.

And boilerplate is a vague term, good example of copilot "AI" features :

  function(a, b, c, d) {
    if(a ...) { ..
    }

    if(b // starts generalizing from a case but is very context aware

    // here it's already doing c and d  
  }

And tests - sometimes it can generate a correct test with mocks just from function name, sometimes it's garbage - but it's really easy to glance at which it is.

My current experience with copilot for ~2 months is that it's really good at such boilerplate, it's annoying when it's late or fails at what I expect it but, and it makes generating boilerplate code very cheap so it can lead to a lot of duplication.

If you're good enough you know to pick up when you should apply DRY and when not, you'll get a feel when copilot is useful and it will be a decent productivity boost IMO. If they made it faster and more reliable (just for the cases I already use it for) I would pay >100$ month out of pocket for sure.

I've found it amazing when working in semi-familiar programming languages. I'm primarily a Ruby dev, but currently working in Python. The languages are close enough that it's an easy transition, but they do a lot of fundamentals differently.

Previously, it'd be extremely disruptive to my thought-process to have to go lookup basic functions, like checking array lengths or running a regex on a string.

Now, I just write a comment like `# check array length` or `# on x_var, run this regex "\s+"`. Copilot spits back what I need (or at least close enough to avoid having to break context).

Even in core languages, I'm finding it very useful for writing system calls or niche functionality that I don't use frequently. My mental model knows what needs to be done, but I don't remember the exact calls off the top of my head.

Copilot is fantastic at predicting where I'm heading next once I give it a little bit of a start. It helps me work out unfamiliar functions that I might need to chain, or syntax I'm not entirely familiar with.

I'd say it's a big winner for me.

In the meantime, I'm training language-specific base models using NeoX blocks. I hope to release them soon.

The Huggingface Space demo is running on a derived model of Salesforce/codegen-350M-multi

If we are talking about open source self-hosted specifically, it's mostly consulting, paid support, and offering managed hosting.

Related research works include [1]. (Hints: combine code search and LLM).

[1]: RepoCoder: Repository-Level Code Completion Through Iterative Retrieval and Generation https://arxiv.org/abs/2303.12570

This also reveals Tabby's roadmap beyond other OSS work like Fauxipilot :)

Making the simpler code much faster to develop leaves me a lot more time and focus for the complex work.

These tools really are amazing, even with their limitations.

I recently needed a script to grab all my github repos from the github api and produce a CSV with the columns URL, name, description, and it could not do that at all. Just hallucinated libraries and APIs that did not exist.

Genuine question, do you not use GitHub for things other than copilot? It seems to me either the privacy issues of copilot are overblown or the privacy issues of GitHub itself are underblown, because they both end up with basically the same data.

I know regular old LSP/Intellisense helps here but you are still often constrained to only autocompleting one token at a time, and have to type it at least partially in most cases.

Tldr; Can't imagine using it with a language that doesn't have great type checking to catch its BS, and they really need to tune how it interacts with traditional intelligence.

Been using it in VSCode with C# and Typescript. It gets in the way of the normal intellisense forcing you to use a shortcut to get out and back to intellisense.

For me this was really getting in the way because working one line at a time when you know what you need isn't its strong suite.

Stubbing out methods or even classes, or offering a "possibly correct" solution in areas you are fuzzy about is a strong point. Even stubbing out objects, methods, and etc using your existing code as a reference point...

But possible is the key. It's a bullshitter so it could randomly invent parameters or interfaces that are plausible, but not real. It also trips up on casing regularly.

All this to say; you gotta review everything it does and be on the lookout. Without the tooling help of a typed lang like c# or typescript this would be much harder.

I thought I was reaching a productive flow with this but then I loaded my proj in Rider, which didn't have copilot installed, and banged out some code and man it was frictionless in comparison.

Feel like copilot should be opt in via a shortcut, not opt out as it is. They really need to work out how to reduce the friction of using intellisense when it's the best option which it often is. But the copilot creators seem dead set on it constantly back-seat driving.

That's a lot less than 100x, but it's way more than nothing! I don't think I'd want to give it up.

Local models are a different game though. I want not an autocomplete, i want to tell it “go do this, similarly how we did it there” and it does it. Basically, a high level dsl, that magically appears after a model looks at your codebase.

However, just yesterday in a module with quite a lot of context and types it autocompleted a function I was pondering for converting between different schema languages.

It was subtly wrong but the basic structure was correct. I had wanted to implement this function for a while but, having not really thought it through, imagined it would be much more complicated and would have required reading the ABI spec for the target. I never would have attempted it unless it had shown me the way and that it was relatively simple.

This is probably a piece of code that saves significant manual code. Copilot doesn't need to nudge me towards writing that many high leverage pieces of code to start becoming a big multiplier.

Now theoretically, I know about those things, but even I'll admit I would have messed up the syntax and probably spent 15m on regex 101 tweaking things. The ai assist is great if you take it as a suggestion of something you should look at, rather than blindly trust it

[1] https://news.ycombinator.com/item?id=35471882

[2] https://news.ycombinator.com/item?id=35471390

I hope these can be of help and answer your questions as well!

Which is pretty entertaining given how many of these companies host their code on Github already.

Or am I misunderstanding the idea here?

That said, local solutions always tend to be lower latency than cloud ones just because you get to skip the network.