killianlucas
Joined 3 years ago
Karma
30
Submissions
14
Member since
Jan 2
build machines that improve the human condition. inspire others to do the same.
View on Hacker NewsRecent submissions
Comment · 1 year ago
It depends where the tech is applied IMO — for your information diet it's destructive to give up any control.
For filling out forms, copying and pasting between tabs, other web drudgery.. I think it's just a bad computing experience, and people would welcome something better than copy/paste (tech from half a century ago!)
Comment · 1 year ago
Our goal is to build this locally— there's even some heuristics we've found (i.e clicking the same items in a row every time you visit a website) that can give really good completions without an LLM.
Chrome is even starting to ship a small Gemma model in the browser, but we haven't seen great performance from Gemma yet.
But yes, and I have the same concerns w/ this, code completions, Grammerly etc. Hopefully all these tools will follow the same trajectory (some usage with a cloud setup -> distilled into a small local setup).
Comment · 3 years ago
Let me know how it goes!
It works without it, but it will struggle with those tasks (https://github.com/KillianLucas/open-procedures/tree/main/pr...) because of GPT-4's training data cutoff.
If you give it the right info (e.g "use Selenium without web package manager") it works without it. Sometimes it experiments and figures it out anyway.
As I use it, do I find lots of tasks it fails at just because of the training data cutoff, so that db is just meant to provide it with up-to-date documentation.
Running OI in `--local` mode will disable it though!
Comment · 3 years ago
Thanks! Custom built, it's actually Tailwind CSS that I made on the https://play.tailwindcss.com/ playground lol. You can write HTML with tailwind there, then just copy the "generated CSS" at the bottom, paste it into a style.css, paste your HTML into a index.html, then upload to github pages.
All static, no building stuff, just that playground + github pages.
The Open Interpreter site is actually open-sourced here if you want to copy it: https://github.com/KillianLucas/open-interpreter-website
Comment · 3 years ago
Same! One path forward with Open Interpreter is to make a "self-writing Jupyter notebook" with the same UI as Jupyter— edit code, rearrange it, export as a py, etc. Any thoughts on how you'd do that deeper notebook/LLM integration, or what it might need?
Comment · 3 years ago
dozens of great ideas in here pedro.
> The main feature allows specific code chunks to be referenced and edited/removed/appended to.
Do you know if it works to just include in the system message something like "When editing a function, don't rewrite the whole thing, be sure to edit modules piecemeal e.g. Foo.NestedFooClass.bar_method = ..."?
> imports could be auto-added when missing and unambiguous
GREAT idea. You're write, tons of low hanging fruit here. A preprocess.py file should probably be added to Open Interpreter with all these ideas— what do LLMs tend to fail at that we can programmatically correct in each code block? Then just run that on each block it writes before asking the user for approval to run it.
> logit warping to boost tokens corresponding to names/keywords valid in the current scope
WOAH. Have you heard of outlines? (https://normal-computing.github.io/outlines/) Lets you put in any Regex you want, then as the LLM is generating, logit bias is used to conform the output to that Regex. Works for local models. I can totally imagine pairing some linting function with outlines to get models to write automatically linted code on the first pass.
For my thing, I abandoned IPython since I wanted a more uniform approach to multiple programming languages. Open Interpreter keeps a single subprocess open with `python -i` to get a live Python interpreter that displays a real-time output. It's acts the same as IPython, but I can just swap out that command (for example, with `node -i`) to get different languages. I think this also gets around the issues with cell magic, which as you've said, might confuse it— instead we just ask the model to tell us what language it wants to use + the code it wants to run in a single function call.
Have thought a lot about letting the user edit code. The next version of Open Interpreter = an electron app with a UI so you can edit code before it runs, better copy/paste, convo history, etc.
> with a broken backspace key
By the way, have you heard of this idea of training models to use a backspace key? Powerful stuff. We could think about implementing this in preprocess.py — another pass by GPT-4 or whatever to edit things it thinks isn't going to work. To the user it would just look like GPT-4 has a working backspace key.
Would love to see your github on these if you're willing to share! Open Interpreter is MIT license so ideally I could make it attractive enough / similar enough to your project to simply join up / contribute some of these ideas.
Comment · 3 years ago
Thanks so much!
Comment · 3 years ago
Yes, you can iterate on the code being written by asking for changes— very much like ChatGPT. If it starts writing code you don't want, you can hit CTRL-C to stop generating, and give it your feedback right away.
And yes, `$: interpreter` runs in confirmation mode by default. You'll need to approve every block of code before it's run (bypass this with the `-y` flag).
Comment · 3 years ago
thanks! there's something magic about LLMs running code, I think.
Comment · 3 years ago
Thank you so much!
Yes, both — anywhere you can run Python.
For app control, we pass in some system information (like OS) into the system message. The LLM then knows to use Applescript for Mac, PowerShell for Windows, `cal` and `alpine` for Linux, etc.
Comment · 3 years ago
aw thanks! I made it with Rotato, highly recommend that. Lots of the animation I actually used Open Interpreter to put together (e.g. "Make a square gif out of these images, cropping out the whitespace in each frame", etc)
Let me know if you get the chance to try it!
Comment · 3 years ago
Hey HN! Over the summer I built Open Interpreter, a CLI that lets you ask Code-Llama to write and run code.
It executes multiple languages (Python, Shell, HTML/CSS, Node JS) then sends the output back to the language model.
It’s essentially an open-source, local implementation of OpenAI’s Code Interpreter, but without limits on file-size, runtime timeouts, or web access.
Everything is streamed beautifully to your terminal and rendered with Markdown and syntax highlighting.
Try it out and let me know what you tried!
- Killian