DEV Community: StackFoss

PCSX2: The Free and Open-Source PlayStation 2 Emulator

StackFoss — Sun, 25 Jun 2023 21:52:43 +0000

PCSX2: The Free and Open-Source PlayStation 2 Emulator

PCSX2 is a remarkable piece of software that allows you to play PlayStation 2 (PS2) games on your PC. As a free and open-source emulator, PCSX2 aims to replicate the PS2's hardware functionality using a combination of interpreters, recompilers, and a virtual machine. With PCSX2, you can enjoy a vast library of PS2 games, including popular titles like Final Fantasy X and Devil May Cry 3, right on your computer.

Project Details

The PCSX2 project has been in development for over twenty years. Initially, early versions of PCSX2 could only run a few public domain game demos. However, thanks to the dedication and hard work of the developers, PCSX2 has evolved into a mature emulator capable of running most PS2 games at full speed. With more than 2500 titles tested, PCSX2 has become a go-to choice for PS2 enthusiasts worldwide.

To stay up-to-date with game compatibility, you can visit the official PCSX2 compatibility list or seek assistance from the vibrant community in the official forums.

The latest stable version of PCSX2 is 1.6.0, offering improved performance, compatibility, and a range of new features. You can download both stable and development builds of PCSX2 from the official website.

System Requirements

To enjoy smooth gameplay and optimal performance with PCSX2, it's essential to ensure your system meets the following minimum requirements:

Minimum System Requirements

Operating System:
- Windows 10 21H2 (1809 or later) (64-bit)
- Ubuntu 20.04/Debian or newer, Arch Linux, or other distro (64-bit)
- macOS 10.14
CPU:
- Supports SSE4.1
- PassMark Thread Performance rating near or greater than 1800
- Two physical cores with hyperthreading
GPU:
- Direct3D10 support
- OpenGL 3.x support
- Vulkan 1.1 support
- Metal support
- PassMark G3D Mark rating around 3000 (e.g., GeForce GTX 750, Radeon RX 560, Intel Arc A380)
- 2 GB Video Memory
RAM: 4 GB

Please note that the CPU requirements may vary depending on the complexity of the games you intend to play. CPU-intensive games may require a higher-rated CPU. You can refer to the PCSX2 wiki and forums for specific CPU recommendations based on game requirements.

Recommended System Requirements

For an optimal gaming experience with PCSX2, it is recommended to have the following specifications:

Operating System:
- Windows 10 21H2 (1809 or later) (64-bit)
- Ubuntu 22.04/Debian or newer, Arch Linux, or other distro (64-bit)
- macOS 10.14
CPU:
- Supports AVX2
- PassMark Single Thread Performance rating near or greater than 2600
- Four physical cores, with or without hyperthreading
GPU:
- Direct3D12 support
- OpenGL 4.6 support
- Vulkan 1.3 support
- Metal support
- PassMark G3D Mark rating around 6000 (

e.g., GeForce GTX 1650, Radeon RX 570)

4 GB Video Memory
RAM: 8 GB

The recommended GPU specifications are based on internal rendering at approximately 1080p resolution. Higher resolutions may require more powerful graphics cards.

It's worth noting that both the CPU and GPU requirements are game-dependent. Some games may have higher demands than others, especially those labeled as CPU or GPU intensive. For a quick reference on game requirements, you can consult the PCSX2 wiki and forums.

Technical Notes

To ensure a smooth experience with PCSX2, consider the following technical notes:

On Windows, you need to install the Visual C++ 2019 x64 Redistributables.
Support for Windows XP and Direct3D9 was discontinued after stable release 1.4.0.
Support for Windows 7, Windows 8.0, and Windows 8.1 was discontinued after stable release 1.6.0.
32-bit and wxWidgets support were dropped after stable release 1.6.0, with the wxWidgets code being entirely removed on December 25th, 2022.
Keeping your operating system and drivers up to date is crucial for the best experience. It is also recommended to have a newer GPU with the latest supported drivers.
To legally use PCSX2, you need to obtain a BIOS dump extracted from a PS2 console that you own. For detailed instructions on acquiring the BIOS, refer to PCSX2's FAQ.
By default, PCSX2 utilizes two CPU cores for emulation. The MTVU speed hack allows the use of a third core, which is compatible with most games and can provide a significant speed boost on CPUs with three or more cores. However, GS-limited games or CPUs with fewer than two cores may experience a slowdown. Software renderers utilize additional threads for rendering and require higher core counts to run efficiently.
The requirements benchmarks provided are based on Passmark's CPU benchmarking software, specifically the "Single Thread Rating" (STR) statistic. You can compare your CPU's performance to PCSX2's requirements by checking its rating on Passmark's CPU benchmark website.
Vulkan support requires an up-to-date GPU driver. Older drivers may cause graphical issues.

For more information and updates, visit the official PCSX2 website. Get ready to relive your favorite PS2 games on your PC with PCSX2, the ultimate PlayStation 2 emulator.

Embedchain: Building LLM-Powered Bots with Ease

StackFoss — Sun, 25 Jun 2023 21:31:41 +0000

Embedchain: Building LLM-Powered Bots with Ease

Embedchain is a powerful framework designed to simplify the process of creating language model (LLM) powered bots using any dataset. It provides an abstraction layer that handles dataset loading, chunking, embedding creation, and storage in a vector database.

By using the .add and .add_local functions, you can easily add single or multiple datasets to your bot. Then, you can utilize the .query function to retrieve answers from the added datasets.

Let's say you want to create a bot based on Naval Ravikant, incorporating one YouTube video, one book in PDF format, two blog posts, and a question and answer pair. With Embedchain, all you need to do is provide the links to the videos, PDF, and blog posts, as well as the Q&A pair. Embedchain will handle the rest, creating a bot tailored to your specifications.

from embedchain import App

naval_chat_bot = App()

# Embed Online Resources
naval_chat_bot.add("youtube_video", "https://www.youtube.com/watch?v=3qHkcs3kG44")
naval_chat_bot.add("pdf_file", "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf")
naval_chat_bot.add("web_page", "https://nav.al/feedback")
naval_chat_bot.add("web_page", "https://nav.al/agi")

# Embed Local Resources
naval_chat_bot.add_local("qna_pair", ("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."))

naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?")
# Answer: Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.

Getting Started

Installation

First, make sure you have the Embedchain package installed. If not, you can install it via pip:

pip install embedchain

Usage

To get started with Embedchain, you'll need an OpenAI account and an API key. If you don't have an API key, you can create one by visiting this link.

Once you have your API key, set it as an environment variable named OPENAI_API_KEY:

import os
os.environ["OPENAI_API_KEY"] = "sk-xxxx"

Next, import the App class from Embedchain and use the .add function to add datasets to your bot:

from embedchain import App

naval_chat_bot = App()

# Embed Online Resources
naval_chat_bot.add("youtube_video", "https://www.youtube.com/watch?v=3qHkcs3kG44")
naval_chat_bot.add("pdf_file", "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf")
naval_chat_bot.add("web_page", "https://nav.al/feedback")
naval_chat_bot.add("web_page", "https://nav.al/agi")

# Embed Local Resources
naval_chat_bot.add_local("qna_pair", ("Who is Naval Ravikant?", "Nav

al Ravikant is an Indian-American entrepreneur and investor."))

If there is another app instance in your script or app, you can change the import as follows:

from embedchain import App as EmbedChainApp

# or

from embedchain import App as ECApp

Now that your app is created, you can use the .query function to retrieve answers for any query:

print(naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?"))
# Answer: Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.

Supported Formats

Embedchain supports the following formats for dataset embedding:

YouTube Video

To add a YouTube video to your app, use the data type (first argument to .add) as "youtube_video". For example:

app.add('youtube_video', 'a_valid_youtube_url_here')

PDF File

To add a PDF file, use the data type as "pdf_file". For example:

app.add('pdf_file', 'a_valid_url_where_pdf_file_can_be_accessed')

Note that password-protected PDFs are not supported.

Web Page

To add a web page, use the data type as "web_page". For example:

app.add('web_page', 'a_valid_web_page_url')

Text

To supply your own text, use the data type as "text" and enter a string. The text is not processed, making it highly versatile. For example:

app.add_local('text', 'Seek wealth, not money or status. Wealth is having assets that earn while you sleep. Money is how we transfer time and wealth. Status is your place in the social hierarchy.')

Note: This example is not used in the provided code snippets because it's more common to supply a whole paragraph or file, which couldn't fit in the code examples.

Q&A Pair

To supply your own question and answer pair, use the data type as "qna_pair" and enter a tuple. For example:

app.add_local('qna_pair', ("Question", "Answer"))

More Formats Coming Soon

If you want to add any other format, please create an issue, and we will consider adding it to the list of supported formats.

How Does It Work?

Creating a chat bot based on a dataset involves several steps, each with its own nuances. Embedchain simplifies this process and provides a straightforward interface to create bots over any dataset.

The steps involved in creating and querying a bot are as follows:

Load the Data : Load the dataset into the bot.
Create Meaningful Chunks : Break the data into meaningful chunks, determining the appropriate chunk size.
Create Embeddings : Generate embeddings for each chunk using an embedding model.
Store Chunks in a Vector Database : Store the chunks, along with their embeddings, in a vector database.
Query the Bot : When a user asks a query, create an embedding for the query and retrieve similar documents from the vector database.
Obtain the Answer : Pass the similar documents as context to the LLM and obtain the final answer.

Embedchain takes care of these steps and handles the underlying complexities. It provides a simplified interface to create bots over any dataset, allowing you to focus on building and deploying your application quickly.

Tech Stack

Embedchain is built on the following technology stack:

[Langchain](https://github.com/hwchase17

/langchain): An LLM (Language Model) framework used to load, chunk, and index data.

OpenAI's Ada embedding model: An embedding model provided by OpenAI used to generate embeddings.
OpenAI's ChatGPT API: An LLM provided by OpenAI used to generate answers given a context.
Chroma: A vector database used to store embeddings.

Author

Taranjeet Singh (@taranjeetio)

Embedchain simplifies the process of creating language-powered bots over any dataset. With its easy-to-use framework, you can quickly build bots that leverage the power of language models to provide answers and insights. Whether you want to create a chatbot for a specific domain or build a knowledge base for a particular topic, Embedchain can help you streamline the development process. Get started with Embedchain today and unlock the potential of language-powered bots in your applications.

Spacedrive: A File Explorer from the Future

StackFoss — Sun, 25 Jun 2023 21:14:37 +0000

Spacedrive: A File Explorer from the Future

Spacedrive is an open source cross-platform file manager powered by a virtual distributed filesystem (VDFS) written in Rust. It aims to provide a secure and intuitive file management experience, combining the storage capacity and processing power of multiple devices into one personal distributed cloud.

Note : Spacedrive is currently under active development, and most of the listed features are still experimental and subject to change.

Features

Virtual Distributed Filesystem (VDFS): Spacedrive utilizes a VDFS to organize files across multiple devices and storage layers. It maintains a virtual index of all storage locations and synchronizes the database between clients in real-time.
Cross-Platform Support : Spacedrive is designed to work seamlessly across various operating systems, including macOS, Windows, Linux, iOS, watchOS, and Android.
Secure and Personal Cloud : With Spacedrive, users can create their own personal distributed cloud, combining the storage capacity and processing power of their devices. This provides increased security and ownership over their data.
Free File Management Experience : Spacedrive offers a free file management experience like no other, catering to independent creatives, hoarders, and anyone who wants to own their digital footprint.

Screenshots

Community and Development

Join the Spacedrive community and stay updated with the latest developments:

License

Spacedrive is licensed under the AGPL v3.0. For more information, refer to the GNU General Public License v3.0.

Development Architecture

Spacedrive uses the "PRRTT" stack (Prisma, Rust, React, TypeScript, Tauri) for its development architecture:

Prisma : Prisma is used on the front-end, thanks to prisma-client-rust by Brendonovich. It provides access to the Prisma migration CLI and syntax for the schema. The application bundles with the Prisma query engine and codegen, offering a powerful Rust API.
Tauri : Spacedrive uses Tauri to create a pure Rust native OS webview, resulting in a smaller bundle size and lower memory usage compared to traditional Electron apps. Tauri contributes to a more native feel, especially on macOS, thanks to Safari's close integration with the operating system.

rspc : The project utilizes rspc, which allows defining functions in Rust and calling them on the TypeScript frontend in a typesafe manner, reducing the chance of bugs making it into production.

sdcore : The core of Spacedrive, referred to as sdcore, is written in pure Rust and handles filesystem, database, and networking logic. It can be deployed in a variety of host applications.

Monorepo Structure

The Spacedrive repository follows a monorepo structure with the following components:

Apps

desktop: A Tauri app for desktop platforms.
mobile: A React Native app for mobile platforms.
web: A React web app.
landing: A React app using Vite SSR & Vite pages for the landing page.

Core

core: The Rust core, known as sdcore, containing filesystem, database, and networking logic. It can be deployed in various host applications.

Packages

client: A TypeScript client library that handles data flow via RPC between the UI and the Rust core.
ui: A shared React component library.
interface: The complete user interface in React, used by the desktop, web, and landing apps.
config: ESLint configurations, including eslint-config-next, eslint-config-prettier, and all tsconfig.json files used throughout the monorepo.
macos: A Swift native binary for macOS system extensions.
ios: A planned Swift native binary for iOS.
windows: A planned C# native binary for Windows.
android: A planned Kotlin native binary for Android.

For detailed instructions on how to install and contribute to Spacedrive, please refer to the contributing guide.

What is a VDFS?

A VDFS (Virtual Distributed Filesystem) is a filesystem designed to work across a variety of storage layers. It provides a uniform API for manipulating and accessing content across multiple devices, eliminating the limitations of a single machine. A VDFS maintains a virtual index of all storage locations, synchronizing the database between clients in real-time. It uses Content-Addressable Storage (CAS) to uniquely identify files while keeping a record of logical file paths relative to the storage locations.

The concept of a VDFS was introduced in a UC Berkeley paper by Haoyuan Li. While the paper focuses on its use in cloud computing, the underlying concepts can be applied to open consumer software.

Motivation

Spacedrive aims to address the challenges of managing multiple cloud accounts, unbacked drives, and data at risk of loss. Traditional cloud services have limited capacity and lack interoperability between services and operating systems. Spacedrive envisions a future where photo albums and data are not tied to device ecosystems or harvested for advertising. It aims to provide an OS-agnostic, permanent, and personally owned file management solution. By leveraging open-source technology, Spacedrive aims to empower users to retain absolute control over the data that defines their lives, with unlimited scalability.

Roadmap

To explore the planned features of Spacedrive, visit the spacedrive.com/roadmap page for a comprehensive list.

Spacedrive is an ambitious project with a roadmap that outlines upcoming enhancements and features. As it continues to evolve, Spacedrive strives to deliver an unparalleled file management experience for users.

Spacedrive is an exciting open-source project that envisions a future where file management is

seamless, secure, and user-centric. With its unique features, cross-platform support, and focus on user ownership, Spacedrive aims to revolutionize how we interact with our digital data. Join the community and be a part of shaping the future of file management.

Skateshop13: An Open Source E-Commerce Skateshop Built with Next.js 13

StackFoss — Sun, 25 Jun 2023 20:56:47 +0000

Skateshop13: An Open Source E-Commerce Skateshop Built with Next.js 13

Skateshop13 is an open source e-commerce skateshop built with the latest features of Next.js 13. This project utilizes the create-t3-app bootstrap and aims to provide a modern and efficient platform for skateshop owners and customers. Although it is still in development, Skateshop13 showcases the potential of new technologies such as server actions and drizzle ORM. However, it is important to note that these technologies are subject to change, and the project is not yet suitable for production use.

Warning

This project is still in development and is not ready for production use.

It uses new technologies (server actions, drizzle ORM) which are subject to change and may break your application.

Tech Stack

Skateshop13 leverages the following technologies:

Next.js: Next.js is a popular React framework for building server-rendered and static websites. It offers powerful features such as automatic code splitting, server-side rendering, and efficient caching.
Clerk Auth: Clerk Auth provides a seamless and secure authentication solution for web applications. Skateshop13 utilizes Clerk Auth for user authentication and authorization.
Drizzle ORM: Drizzle ORM is a modern object-relational mapper (ORM) that simplifies database interactions in Next.js applications. Skateshop13 integrates Drizzle ORM to manage database operations efficiently.
Tailwind CSS: Tailwind CSS is a utility-first CSS framework that enables developers to rapidly build custom designs with reusable components. Skateshop13 utilizes Tailwind CSS for its flexible and customizable styling.
uploadthing: uploadthing is a file upload service used by Skateshop13 to handle file uploads efficiently and securely.
Stripe: Stripe is a popular payment processing platform. Skateshop13 integrates Stripe for subscription management, payment processing, and billing functionality.

Features

Skateshop13 offers the following features:

Authentication with Clerk : Skateshop13 provides a seamless authentication experience powered by Clerk Auth. Users can create accounts, log in, and enjoy personalized shopping experiences.
File Uploads with uploadthing : Skateshop13 leverages uploadthing to enable users to upload and manage files securely. This feature is especially useful for users who want to upload images or other files related to their skateshop products.
Subscription, Payment, and Billing with Stripe : Skateshop13 integrates with Stripe to enable subscription-based services, handle payments securely, and manage billing for skateshop owners and customers.
Storefront with Products and Categories : Skateshop13 offers a fully functional storefront where skateshop owners can showcase their products. Products are organized into categories, allowing users to easily browse and find items of interest.
Seller and Customer Workflows : Skateshop13 supports both seller and customer workflows. Skateshop owners can manage their stores, products, orders, subscriptions, and payments through the admin dashboard, while customers can browse products, place orders, and manage their subscriptions.
Admin Dashboard : Skateshop13 provides an intuitive admin dashboard that empowers skateshop owners to manage various aspects of their business. From the dashboard, owners can manage stores, products, orders, subscriptions, and payments efficiently.

Installation

To install and set up Skateshop13 on your local environment, follow these steps:

1. Clone the repository

Clone the Skateshop13 repository by running the

following command in your terminal:

git clone https://github.com/sadmann7/skateshop

2. Install dependencies

Navigate to the project's root directory and install the required dependencies by running the following command:

pnpm install

3. Create a `.env` file

Create a new file called .env in the project's root directory. Copy the environment variables from the .env.example file and set their values as appropriate for your environment.

4. Run the application

Start the Skateshop13 application by running the following command:

pnpm run dev

5. Push the database

To initialize the database, run the following command:

pnpm run db:push

6. Listen for Stripe events

To enable the handling of Stripe events, run the following command:

pnpm run stripe:listen

Deployment

If you wish to deploy Skateshop13, refer to the deployment guides for Vercel, Netlify, and Docker for detailed instructions.

Deploying Skateshop13 on these platforms will allow you to make your e-commerce skateshop accessible to a wider audience while taking advantage of the benefits provided by each deployment option.

Note that before deploying, ensure that you have properly configured the required environment variables and have followed any additional deployment-specific steps outlined in the respective guides.

Skateshop13 is a promising open source project that combines the power of Next.js 13 with various modern technologies to deliver a robust and feature-rich e-commerce platform for skateshops. While still under development, it already offers impressive functionalities for both skateshop owners and customers. With further enhancements and refinements, Skateshop13 has the potential to revolutionize the way skateshops operate and serve their customers in the digital age.

Cybernetically Enhanced Web Apps: Svelte

StackFoss — Sat, 24 Jun 2023 13:46:25 +0000

Cybernetically Enhanced Web Apps: Svelte

Introduction

In the world of web development, innovation and efficiency are key factors in creating successful applications. Svelte, a cutting-edge technology, offers a fresh approach to building web applications. By utilizing a compiler, Svelte transforms declarative components into highly efficient JavaScript code that updates the Document Object Model (DOM) with surgical precision. This article explores the features, benefits, and contributions surrounding Svelte.

What is Svelte?

Svelte is a revolutionary tool that simplifies the process of web application development. Unlike traditional frameworks or libraries that rely on runtime interpretation, Svelte takes a different approach. It compiles components into optimized JavaScript code during the build process, resulting in lightweight and performant applications.

The fundamental principle of Svelte is that it shifts the heavy lifting from the browser to the build process. Instead of shipping a framework to the client and interpreting it at runtime, Svelte compiles the application code into small and efficient JavaScript files. This approach eliminates the need for a runtime framework, resulting in faster loading times and improved overall performance.

To learn more about Svelte, visit the official Svelte website or join the vibrant Discord chatroom where you can engage with the Svelte community.

Supporting Svelte

Svelte is an open-source project released under the MIT license. The ongoing development and maintenance of Svelte are made possible by the hard work and dedication of its volunteers. If you appreciate the benefits of Svelte and would like to support its continued growth, consider becoming a backer on Open Collective. Donations made through Open Collective contribute to expenses such as hosting costs and may even directly support the development of Svelte.

Roadmap

To gain insights into the future direction of Svelte, you can explore the project's roadmap. The roadmap provides an overview of the features and enhancements planned for upcoming releases, offering an exciting glimpse into the evolution of Svelte.

Contributing to Svelte

Svelte welcomes contributions from the community. If you're interested in getting involved, please refer to the Contributing Guide and the svelte package for detailed information on how to contribute effectively.

Development

Svelte encourages pull requests and appreciates contributions from developers of all levels. You can make a positive impact on the project by tackling open issues. To get started with local development of Svelte, follow these steps:

Clone the Svelte repository:

git clone https://github.com/sveltejs/svelte.git
cd svelte
pnpm install

Note: Ensure you use pnpm to install the dependencies, as specified in the pnpm-lock.json file.

Build the compiler and other included modules:

pnpm build

Continuously rebuild the package while watching for changes (useful when using pnpm link to test changes locally in a project):

pnpm dev

The Svelte compiler is primarily written in TypeScript, a superset of JavaScript. Don't be intimidated if you're new

to TypeScript—it is similar to JavaScript with the addition of type annotations. If you're using an editor other than Visual Studio Code, consider installing a plugin to enable syntax highlighting and code hints for TypeScript.

Running Tests

Svelte has a comprehensive test suite to ensure the stability and reliability of the project. You can run the tests using the following command:

pnpm test

To filter specific tests, you can use the -g or --grep option. For example, if you only want to run tests related to transitions, use the following command:

pnpm test -- -g transition

svelte.dev

The source code for the official Svelte website, https://svelte.dev, resides in the sites repository. The website's documentation is located in the site/content directory. The Svelte website is built using SvelteKit, an intuitive framework for building web applications.

Troubleshooting

If you experience difficulty accessing any .dev sites, including https://svelte.dev, there might be a possible issue. You can refer to this SuperUser question and answer for troubleshooting steps and solutions.

License

Svelte is released under the MIT license, granting users the freedom to use, modify, and distribute the software for both personal and commercial purposes.

In conclusion, Svelte offers a new paradigm for building web applications, empowering developers with a highly efficient and performant approach. With its focus on compilation and optimized JavaScript output, Svelte enables the creation of cybernetically enhanced web apps that deliver an exceptional user experience. Join the Svelte community today and be a part of shaping the future of web development.

Generative Models by Stability AI

StackFoss — Sat, 24 Jun 2023 13:38:03 +0000

Generative Models by Stability AI

News

June 22, 2023

We are releasing two new diffusion models for research purposes:
- SD-XL 0.9-base: The base model was trained on a variety of aspect ratios on images with resolution 1024^2. The base model uses OpenCLIP-ViT/G and CLIP-ViT/L for text encoding whereas the refiner model only uses the OpenCLIP model.
- SD-XL 0.9-refiner: The refiner has been trained to denoise small noise levels of high quality data and as such is not expected to work as a text-to-image model; instead, it should only be used as an image-to-image model.

If you would like to access these models for your research, please apply using one of the following links:

SDXL-0.9-Base model, and SDXL-0.9-Refiner.

This means that you can apply for any of the two links - and if you are granted - you can access both.

Please log in to your HuggingFace Account with your organization email to request access.

We plan to do a full release soon (July).

The codebase

General Philosophy

Modularity is king. This repo implements a config-driven approach where we build and combine submodules by calling instantiate_from_config() on objects defined in yaml configs. See configs/ for many examples.

Changelog from the old `ldm` codebase

For training, we use pytorch-lightning, but it should be easy to use other training wrappers around the base modules. The core diffusion model class (formerly LatentDiffusion, now DiffusionEngine) has been cleaned up:

No more extensive subclassing! We now handle all types of conditioning inputs (vectors, sequences and spatial conditionings, and all combinations thereof) in a single class: GeneralConditioner, see sgm/modules/encoders/modules.py.
We separate guiders (such as classifier-free guidance, see sgm/modules/diffusionmodules/guiders.py) from the samplers (sgm/modules/diffusionmodules/sampling.py), and the samplers are independent of the model.
We adopt the "denoiser framework" for both training and inference (most notable change is probably now the option to train continuous time models):
- Discrete times models (denoisers) are simply a special case of continuous time models (denoisers); see sgm/modules/diffusionmodules/denoiser.py.
- The following features are now independent: weighting of the diffusion loss function (sgm/modules/diffusionmodules/denoiser_weighting.py), preconditioning of the network (sgm/modules/diffusionmodules/denoiser_scaling.py), and sampling of noise levels during training (sgm/modules/diffusionmodules/sigma_sampling.py).
Autoencoding models have also been cleaned up.

Installation:

1. Clone the repo

git clone git@github.com:Stability-AI/generative

-models.git
cd generative-models

2. Setting up the virtualenv

This is assuming you have navigated to the generative-models root after cloning it.

NOTE: This is tested under python3.8 and python3.10. For other python versions, you might encounter version conflicts.

PyTorch 1.13

# install required packages from pypi
python3 -m venv .pt1
source .pt1/bin/activate
pip3 install wheel
pip3 install -r requirements_pt13.txt

PyTorch 2.0

# install required packages from pypi
python3 -m venv .pt2
source .pt2/bin/activate
pip3 install wheel
pip3 install -r requirements_pt2.txt

Inference:

We provide a streamlit demo for text-to-image and image-to-image sampling in scripts/demo/sampling.py. The following models are currently supported:

Weights for SDXL :

If you would like to access these models for your research, please apply using one of the following links:

SDXL-0.9-Base model, and SDXL-0.9-Refiner.

This means that you can apply for any of the two links - and if you are granted - you can access both.

Please log in to your HuggingFace Account with your organization email to request access.

After obtaining the weights, place them into checkpoints/.

Next, start the demo using

streamlit run scripts/demo/sampling.py --server.port <your_port>

Invisible Watermark Detection

Images generated with our code use the

invisible-watermark

library to embed an invisible watermark into the model output. We also provide

a script to easily detect that watermark. Please note that this watermark is

not the same as in previous Stable Diffusion 1.x/2.x versions.

To run the script you need to either have a working installation as above or

try an experimental import using only a minimal amount of packages:

python -m venv .detect
source .detect/bin/activate

pip install "numpy>=1.17" "PyWavelets>=1.1.1" "opencv-python>=4.1.0.25"
pip install --no-deps invisible-watermark

To run the script you need to have a working installation as above. The script

is then useable in the following ways (don't forget to activate your

virtual.

Controlled File System Interaction and Script Execution with Kaguya: A ChatGPT Plugin

StackFoss — Fri, 23 Jun 2023 10:01:47 +0000

Kaguya: Empowering Developers with Controlled File System Interaction

Kaguya is a powerful ChatGPT plugin designed to provide developers with enhanced control over their local files. With Kaguya, you can seamlessly load and edit your files in a controlled manner, while also running Python, JavaScript, and bash scripts directly from within ChatGPT. This innovative tool revolutionizes the way developers interact with their file systems, enabling efficient collaboration and development workflows.

API Endpoints

Kaguya offers a comprehensive set of API endpoints that allow you to interact with your file system seamlessly. The API is documented in the openapi.yaml file and provides the following functionality:

POST /api/executeCommand: Execute a shell command.
GET /api/listFilesInDirectory: List files and directories in the specified directory.
GET /api/readFile: Read the content of a file in the user's directory.
POST /api/update: Update a file in the user's directory by performing a search-and-replace operation.
POST /api/updateWholeFile: Replace the entire content of a file in the user's directory.
POST /api/createFile: Create a new file.
POST /api/deleteFile: Delete a file in the user's directory.
POST /api/renameFile: Rename a file in the user's directory.
POST /api/appendToFile: Append content to the end of an existing file.
POST /api/createDirectory: Create a new directory.
POST /api/deleteDirectory: Delete a directory and its contents.
POST /api/readMultipleFiles: Read the content of multiple files.

These API endpoints empower developers with granular control over their files and directories, making it easy to perform a wide range of file system operations.

Running the Project

Getting started with Kaguya is straightforward. You can run the project using Docker by executing the docker.sh script:

docker.sh

Once the script is executed, you can access Kaguya through ChatGPT by using the appropriate localhost port.

Discover Kaguya in Action

To get a firsthand look at Kaguya's capabilities, check out the demo videos shared on Twitter:

These demos showcase how Kaguya seamlessly integrates with ChatGPT, empowering developers with efficient file system interaction and script execution.

Join the Kaguya Community on Discord

For further engagement and support, we invite you to join our Discord server. Connect with like-minded developers, share your experiences, and stay up to date with the latest Kaguya developments. Join our Discord community here.

Experience the power and convenience of Kaguya as it transforms the way developers work with their local files. Elevate your development workflow and unlock new possibilities with Kaguya today!

Linen: The Future of Community Chat

StackFoss — Fri, 23 Jun 2023 09:23:12 +0000

Linen: The Future of Community Chat

Linen is a revolutionary community chat tool designed to provide an alternative to closed platforms like Slack and Discord. It offers the benefits of real-time communication while incorporating the organizational advantages of traditional forums. With Linen, communities can enjoy a structured and searchable environment, ensuring that valuable information is easily accessible.

Philosophy

Modern communities heavily rely on chat applications for seamless collaboration and communication. While tools like Slack and Discord excel in providing fast real-time responses, they often become overwhelming and chaotic repositories of information. In the past, communities thrived in forums, which offered better structure and search-engine friendliness. At Linen, we believe in a hybrid model that combines the advantages of real-time chat with the organizational benefits of a forum.

Linen is committed to fostering better community interactions, and we provide our platform free of charge, ensuring unlimited message retention for all users. You can sign up and experience the Linen community at Linen.community.

For the Linen Cloud edition, visit linen.dev. Join our public community by following this link: linen.dev/s/linen.

Development Philosophy

At Linen, our development philosophy revolves around delivering the smallest functioning features that significantly enhance users' lives and then iterating upon them. We strive for continuous improvement and actively incorporate user feedback into our development process.

Core Features

Linen offers a range of powerful features that set it apart from traditional chat platforms. These features include:

1. Search Engine Friendly

Unlike most chat applications that heavily rely on JavaScript, Linen communities prioritize search engine friendliness. With over 50,000 pages indexed on Google and more than 10,000,000 search impressions, Linen ensures that your community's content is easily discoverable. We achieve this by providing a sitemap, conditionally rendering a static version of our pages for search engines, and implementing cursor-based pagination to maintain consistency.

2. Customer Support Tooling

Communities often become hubs for customer support, and Linen understands this dynamic. To streamline customer support processes, Linen incorporates a dedicated customer support tooling system. All threads have an open/close state, and we offer a feed that allows you to browse all open and closed conversations in one centralized location. This feature eliminates the need to worry about missed messages across different channels and conversations.

3. Async First Approach

Recognizing that chat environments can quickly become noisy, especially within large communities, Linen employs an "async first" approach. By providing a feed of conversations in which you actively participate, you can stay informed without the fear of missing important messages. Additionally, we have reimagined @mentions as async notifications. Instead of interruptive notifications, they appear in your feed as !mentions. If urgency is required, Linen offers the option to send a push notification with !mention.

4. Import Communities

Linen supports the seamless import of public conversations, attachments, emojis, and members from popular platforms like Slack and Discord. Transitioning to Linen has never been easier, ensuring a smooth migration process for your community.

5. Single Account Across Multiple Communities

Say goodbye to managing multiple emails and passwords for different communities. With Linen, you can join multiple communities using a single login, simplifying your community engagement and collaboration experience.

6. Private Communities

In addition to public communities, Linen offers support for private communities that require a password for access. This feature is ideal for internal team discussions or exclusive community spaces.

7. Thread and Message Management

Linen empowers users with the ability to efficiently manage threads and messages. You can easily drag and drop messages, merging them into a single thread. Furthermore, moving threads between channels is a simple process, enabling streamlined organization within your community.

8. Discord Forum Support

Linen synchronizes with Discord and enhances its search engine friendliness. This integration allows you to enjoy the benefits of Linen's structured community environment while leveraging the familiarity and features of Discord.

9. Private Channels

Linen offers private channels that are invite-only within your community. This feature allows you to create exclusive spaces for specific groups or purposes, ensuring privacy and control over communication.

10. Direct Messages

Engage in direct messages within your Linen community. Connect with individuals privately, fostering personalized and efficient communication channels.

Roadmap

Linen is continually evolving, and we have an exciting roadmap of future developments. Here are some of the upcoming features and improvements we have planned:

1. Github Integration

We understand that many open-source communities rely on GitHub issues to manage their projects. Linen aims to streamline this process by allowing you to tag conversations with specific GitHub issues. This integration will automatically post messages when tickets are closed or updated, keeping your community informed about the progress of relevant issues.

2. Improved Search Functionality

While our current search functionality utilizes full-text search with PostgreSQL, we are dedicated to further enhancing the search experience. We are considering hosting a separate search service to provide even more powerful and accurate search capabilities.

3. Desktop and Mobile Clients

To ensure a seamless user experience, we are actively developing desktop and mobile clients for Linen. These dedicated applications will provide push notifications for urgent messages, allowing you to stay connected and informed across multiple devices.

4. Botting and Automation

Linen aims to empower users with custom botting and automation capabilities. Soon, you will be able to build and add your own custom bots, further enhancing community interactions and automating routine tasks.

Feedback

Linen is currently in its early stages of development, and we highly value user feedback. Your insights and suggestions play a crucial role in shaping the future of Linen. We encourage you to share your thoughts, ideas, and concerns with us, helping us improve and tailor Linen to your needs.

Miscellaneous Features

In addition to the core features outlined above, Linen offers several supplementary features to enhance your community experience. These features include:

Markdown message support
Custom community branding
Custom domain hosting for Cloud edition
Attachments support
Emoji support

Documentation

To help you navigate and utilize Linen effectively, we have divided our documentation into several sections. These sections cover various aspects of Linen's functionality, allowing you to make the most out of the platform. Here are some key sections:

Developer Docs

Getting Started

Desktop Client Releases

Stay up-to-date with the latest releases of Linen's desktop client by visiting our GitHub repository:

https://github.com/Linen-dev/desktop-client/releases

Join us on this exciting journey as we revolutionize the way communities interact and collaborate. Together, let's embrace the future of community chat with Linen!

Copybara: A Tool for Transforming and Moving Code between Repositories

StackFoss — Thu, 22 Jun 2023 10:30:43 +0000

Copybara: A Tool for Transforming and Moving Code between Repositories

Copybara is an internal tool developed and used by Google to facilitate the transformation and movement of code between repositories. It addresses the need for code to exist in multiple repositories and provides a solution for keeping them in sync. One common use case is maintaining a confidential repository alongside a public repository.

To ensure there is always one source of truth, Copybara requires the selection of an authoritative repository. However, contributions can be made to any repository, and any repository can be used to cut a release. The tool simplifies the repetitive movement of code between repositories, and it can also be used for one-time code transfers to a new repository.

The main features of Copybara include its stateless nature and the ability to store state in the destination repository as a label in the commit message. This allows multiple users or services to utilize Copybara with the same configuration and repositories, ensuring consistent results.

Currently, Copybara supports Git repositories as the primary repository type. It also has experimental support for reading from Mercurial repositories. The extensible architecture of Copybara enables the addition of custom origins and destinations for various use cases. Official support for other repository types is planned for future releases.

Example

Here is an example of how Copybara is used in a Python workflow:

core.workflow(
    name = "default",
    origin = git.github_origin(
      url = "https://github.com/google/copybara.git",
      ref = "master",
    ),
    destination = git.destination(
        url = "file:///tmp/foo",
    ),

    # Copy everything but don't remove a README_INTERNAL.txt file if it exists.
    destination_files = glob(["third_party/copybara/**"], exclude = ["README_INTERNAL.txt"]),

    authoring = authoring.pass_thru("Default email <default@default.com>"),
    transformations = [
        core.replace(
                before = "//third_party/bazel/bashunit",
                after = "//another/path:bashunit",
                paths = glob(["**/BUILD"])),
        core.move("", "third_party/copybara")
    ],
)

To run the Copybara workflow:

$ (mkdir /tmp/foo ; cd /tmp/foo ; git init --bare)
$ copybara copy.bara.sky

Getting Started with Copybara

As Copybara doesn't have an official release process yet, you need to compile it from the latest source code. Follow these steps to get started:

Install JDK 11 from the Oracle website.
Install Bazel by following the official installation guide.
Clone the Copybara source code repository locally using the command: git clone https://github.com/google/copybara.git.
Build Copybara:
- Run bazel build //java/com/google/copybara to build the project.
- Run bazel build //java/com/google/copybara:copybara_deploy.jar to create an executable uberjar.
Optionally, you can run tests to ensure the integrity of the codebase using the command: bazel test //.... Note that some tests may require additional tools such as Mercurial or Quilt.

System Packages

You can install system packages required by Copybara using the package manager for your operating system. Here's an example for Arch Linux using the AUR:

Install the package copybara-git from the AUR.

Using Intellij with Bazel Plugin

If you're using IntelliJ with the Bazel plugin, you can configure the

project as follows:

directories:
  copybara/integration
  java/com/google/copybara
  javatests/com/google/copybara
  third_party

targets:
  //copybara/integration/...
  //java/com/google/copybara/...
  //javatests/com/google/copybara/...
  //third_party/...

Note that configuration files can be stored anywhere, but it is recommended to treat them as source code and store them in a version control system like Git.

Building Copybara in an External Bazel Workspace

To build Copybara in an external Bazel workspace, you can define convenience macros for its dependencies. Add the following code to your WORKSPACE file, replacing {{ sha256sum }} and {{ commit }} with the appropriate values:

http_archive(
  name = "com_github_google_copybara",
  sha256 = "{{ sha256sum }}",
  strip_prefix = "copybara-{{ commit }}",
  url = "https://github.com/google/copybara/archive/{{ commit }}.zip",
)

load("@com_github_google_copybara//:repositories.bzl", "copybara_repositories")
copybara_repositories()

load("@com_github_google_copybara//:repositories.maven.bzl", "copybara_maven_repositories")
copybara_maven_repositories()

load("@com_github_google_copybara//:repositories.go.bzl", "copybara_go_repositories")
copybara_go_repositories()

You can then build and run the Copybara tool within your workspace using the command:

bazel run @com_github_google_copybara//java/com/google/copybara -- <args...>

Using Docker to Build and Run Copybara

Please note that Docker usage with Copybara is currently experimental. To build Copybara using Docker, follow these steps:

docker build --rm -t copybara .

Once the build process is complete, you can run the Copybara image from the root of the code you want to use Copybara on:

docker run -it -v "$(pwd)":/usr/src/app copybara copybara

Several environment variables are available to customize the execution of Copybara within the Docker container. Here's an example with custom options:

docker run \
    -e COPYBARA_CONFIG='other.config.sky' \
    -e COPYBARA_SUBCOMMAND='validate' \
    -v "$(pwd)":/usr/src/app \
    -it copybara copybara

Git Config and Credentials

To share your Git configuration and SSH credentials with the Docker container, you can mount the necessary directories. Here's an example for macOS:

docker run \
    -v ~/.ssh:/root/.ssh \
    -v ~/.gitconfig:/root/.gitconfig \
    -v "$(pwd)":/usr/src/app \
    -it copybara copybara

Documentation

While the official documentation for Copybara is still a work in progress, you can find some resources to get started:

Contact

If you have any questions about how Copybara works, you can reach out to Copybara team through our mailing list.

Optional Tips

Here's an optional tip for Bazel users who want to see test errors directly in the Bazel output:

Open your ~/.bazelrc file.
Add the

following line:

test --test_output=streamed

With this configuration, test errors will be displayed directly in the Bazel output instead of having to manually inspect the logs.

These instructions should help you get started with Copybara and explore its capabilities. If you have any further questions or need assistance, don't hesitate to reach out to the Copybara community or the developers working on the project.

Flowise - LangchainJS UI: Build Customized LLM Flows with Drag & Drop Interface

StackFoss — Thu, 22 Jun 2023 10:10:08 +0000

Flowise - LangchainJS UI

Drag & drop UI to build your customized LLM flow using LangchainJS

Quick Start

Download and Install NodeJS >= 18.15.0

Install Flowise
Start Flowise
Open http://localhost:3000

Docker

Docker Compose

Go to the docker folder at the root of the project
Create an .env file and specify the PORT (refer to .env.example)
Run docker-compose up -d
Open http://localhost:3000
You can bring the containers down by running docker-compose stop

Docker Image

Build the image locally:
Run the image:
Stop the image:

Developers

Flowise has 3 different modules in a single mono repository.

server: Node backend to serve API logics
ui: React frontend
components: Langchain components

Prerequisite

Install Yarn v1

Setup

Clone the repository
Go into the repository folder
Install all dependencies of all modules:
Build all the code:
Start the app:
For development build:

Authentication

To enable app-level authentication, add FLOWISE_USERNAME and FLOWISE_PASSWORD to the .env file in packages/server:

FLOWISE_USERNAME=user
FLOWISE_PASSWORD=1234

Documentation

Flowise Docs

Self Host

[Railway](https://docs.flowiseai.com/deployment/railway

)

Render

AWS

Azure

DigitalOcean

GCP

Cloud Hosted

Coming soon

Support

Feel free to ask any questions, raise problems, and request new features in the discussion section.

Contributing

See the contributing guide. Reach out to us on Discord if you have any questions or issues.

License

Source code in this repository is made available under the MIT License.

Tinygrad: A Simple Deep Learning Framework

StackFoss — Thu, 22 Jun 2023 09:57:17 +0000

Introduction to tinygrad: A Simple Deep Learning Framework

tinygrad is a deep learning framework that aims to provide a balance between the simplicity of karpathy/micrograd and the functionality of PyTorch. Maintained by tiny corp, tinygrad is designed to be an easy-to-use framework for adding new accelerators and supports both inference and training. While it may not be the most advanced deep learning framework available, it offers a straightforward and accessible solution for developing machine learning models. In this article, we will explore the features, architecture, and potential applications of tinygrad.

Features

LLaMA and Stable Diffusion

One notable feature of tinygrad is its ability to run LLaMA and Stable Diffusion algorithms. These algorithms are useful in various applications, and tinygrad provides a convenient environment for implementing them. To learn more about LLaMA and Stable Diffusion, refer to the LLaMA showcase and Stable Diffusion showcase in the documentation.

Laziness

tinygrad leverages the power of laziness to optimize computations. For example, when performing a matrix multiplication (matmul), the framework fuses the operation into a single kernel, resulting in efficient execution. Consider the following code snippet:

DEBUG=3 python3 -c "from tinygrad.tensor import Tensor;
N = 1024; a, b = Tensor.rand(N, N), Tensor.rand(N, N);
c = (a.reshape(N, 1, N) * b.permute(1,0).reshape(1, N, N)).sum(axis=2);
print((c.numpy() - (a.numpy() @ b.numpy())).mean())"

By executing the code and setting the DEBUG variable to 3, you can observe the optimization performed by tinygrad. Additionally, increasing the DEBUG value to 4 reveals the generated code. This laziness feature allows for efficient computation and optimization of deep learning models.

Neural Networks

tinygrad recognizes that a significant portion of building neural networks relies on a reliable autograd/tensor library. With tinygrad, you can easily construct neural networks using the available tensor operations and autograd capabilities. The following example demonstrates the construction and training of a neural network using tinygrad:

from tinygrad.tensor import Tensor
import tinygrad.nn.optim as optim

class TinyBobNet:
  def __init__ (self):
    self.l1 = Tensor.uniform(784, 128)
    self.l2 = Tensor.uniform(128, 10)

  def forward(self, x):
    return x.dot(self.l1).relu().dot(self.l2).log_softmax()

model = TinyBobNet()
optim = optim.SGD([model.l1, model.l2], lr=0.001)

# ... complete data loader here

out = model.forward(x)
loss = out.mul(y).mean()
optim.zero_grad()
loss.backward()
optim.step()

In this example, a simple neural network, TinyBobNet, is defined with two linear layers (l1 and l2). The forward method specifies the forward pass of the network. The example also demonstrates the usage of an optimizer, SGD, and the typical training loop involving forward and backward passes.

Accelerators

tinygrad supports various accelerators out of the box, including CPU, GPU (OpenCL), C Code (Clang), LLVM, METAL,

CUDA, Triton, and even PyTorch. These accelerators provide hardware acceleration for the computations performed by tinygrad, improving the performance and efficiency of deep learning models. Adding support for additional accelerators is also straightforward. An accelerator only needs to implement a set of low-level operations, totaling 26 (optionally 27). For more information on adding new accelerators, consult the documentation on adding new accelerators.

Installation

To install tinygrad, the recommended method is to build it from source. Follow the steps below to install tinygrad on your system:

From Source

Clone the tinygrad repository:

git clone https://github.com/geohot/tinygrad.git
cd tinygrad

Install the package using pip:

python3 -m pip install -e . # or `py3 -m pip install -e .` if you are on windows

Remember to include the . at the end of the command.

Documentation

The tinygrad documentation, including a quick start guide, can be found in the docs/ directory. The documentation provides detailed information on the various aspects of using tinygrad, such as tensors, autograd, optimizers, and more.

Quick Example comparing to PyTorch

Here is a quick example that demonstrates the usage of tinygrad and compares it to the equivalent code in PyTorch:

from tinygrad.tensor import Tensor

x = Tensor.eye(3, requires_grad=True)
y = Tensor(&lsqb;&lsqb;2.0,0,-2.0&rsqb;&rsqb;, requires_grad=True)
z = y.matmul(x).sum()
z.backward()

print(x.grad.numpy()) # dz/dx
print(y.grad.numpy()) # dz/dy

The equivalent code in PyTorch:

import torch

x = torch.eye(3, requires_grad=True)
y = torch.tensor(&lsqb;&lsqb;2.0,0,-2.0&rsqb;&rsqb;, requires_grad=True)
z = y.matmul(x).sum()
z.backward()

print(x.grad.numpy()) # dz/dx
print(y.grad.numpy()) # dz/dy

This example demonstrates the similarity between tinygrad and PyTorch in terms of tensor operations and autograd functionality.

Contributing

tinygrad has received significant interest from the community, and contributions are welcome. If you're interested in contributing to the project, here are some guidelines to follow:

Bug fixes are highly appreciated and always welcome. If you encounter a bug, feel free to submit a fix.
When modifying the code, make sure you understand the changes you're making.
Code golf pull requests will be closed, but conceptual cleanups are encouraged.
If you're adding new features, please include appropriate tests to ensure their correctness.
Improving test coverage is highly beneficial. Reliable and non-brittle tests are encouraged.

For more detailed guidelines, refer to the CONTRIBUTING.md file in the repository.

Running Tests

To run the full test suite of tinygrad, you can use the following examples:

python3 -m pip install -e '.[testing]'
python3 -m pytest
python3 -m pytest -v -k TestTrain
python3 ./test/models/test_train.py TestTrain.test_efficientnet

These commands install the necessary dependencies for testing and execute the tests.

Conclusion

tinygrad offers a simple yet powerful framework for deep learning. Its ease of use, support for various accelerators, and compatibility with PyTorch make it an attractive option for developers and researchers. Whether you're building neural networks, implementing advanced algorithms like

LLaMA and Stable Diffusion, or exploring new accelerators, tinygrad provides a solid foundation. With ongoing development and community contributions, tinygrad is poised to grow and become a valuable tool in the machine learning ecosystem.

To learn more about tinygrad, visit the GitHub repository and the official website.

OpenChat: Simplifying Chatbot Creation with Large Language Models

StackFoss — Wed, 21 Jun 2023 18:54:14 +0000

OpenChat: Simplifying Chatbot Creation with Large Language Models

Introduction

OpenChat is an everyday user chatbot console that simplifies the utilization of large language models. As AI continues to advance, the installation and usage of these models have become overwhelming. OpenChat aims to address this challenge by providing a two-step setup process to create a comprehensive chatbot console. It serves as a central hub for managing multiple customized chatbots.

Important disclaimer: This project is not production-ready and is meant for a local environment at this early stage. We quickly built this project to validate the idea, so please excuse any shortcomings in the code. You may come across several areas that require enhancements, and we truly appreciate your support by opening issues, submitting pull requests, and providing suggestions.

Try OpenChat Now

You can try OpenChat on openchat.so. Visit the website to explore the capabilities of OpenChat and experience the power of large language models in chatbot development.

Current Features

OpenChat provides the following features to simplify chatbot creation and management:

Create unlimited local chatbots based on GPT-3 (and GPT-4 if available).
Customize your chatbots by providing PDF files, websites, and soon, integrations with platforms like Notion, Confluence, and Office 365.
Each chatbot has unlimited memory capacity, enabling seamless interaction with large files such as a 400-page PDF.
Embed chatbots as widgets on your website or internal company tools.
Use your entire codebase as a data source for your chatbots (pair programming mode).
And much more!

Roadmap

OpenChat is continuously evolving and improving. Here is the roadmap for upcoming features and enhancements:

Create unlimited chatbots
Share chatbots via URL
Integrate chatbots on any website using JS (as a widget on the bottom right corner)
Support GPT-3 models
Support vector database to provide chatbots with larger memory
Accept websites as a data source
Accept PDF files as a data source
Support multiple data sources per chatbot
Support ingesting an entire codebase using GitHub API and

use it as a data source with pair programming mode

Support pre-defined messages with a single click
Support Slack integration (allow users to connect chatbots with their Slack workspaces)
Support Intercom integration (enable users to sync chat conversations with Intercom)
Support offline open-source models (e.g., Alpaca, LLM drivers)
Support Vertex AI and Palm as LLMs
Support Confluence, Notion, Office 365, and Google Workspace
Refactor the codebase to be API ready
Create a new UI designer for website-embedded chatbots
Support custom input fields for chatbots
Support offline usage: this is a major feature, OpenChat will operate fully offline with no internet connection at this stage (offline LLMs, offline Vector DBs)

We welcome your feedback and ideas! If you have any suggestions or cool ideas, feel free to reach out to us.

Getting Started

To get started with OpenChat, follow these steps:

Make sure you have Docker installed on your machine.
Clone the OpenChat Git repository by running the following command:

git clone git@github.com:openchatai/OpenChat.git

Update the common.env file with your API keys:

OPENAI_API_KEY=# you can get it from your account in openai.com
PINECONE_API_KEY=# you can get from "API Keys" tab in pinecone
PINECONE_ENVIRONMENT=# you can get it after creating your index in pinecone
PINECONE_INDEX_NAME=# you can get it after creating your index in pinecone

Note: For Pinecone DB, make sure that the dimension is equal to 1536.

Navigate to the repository folder and run the following command:

make install

Once the installation is complete, you can access the OpenChat console at http://localhost:8000.

Upgrade Guide

OpenChat strives to avoid introducing breaking changes. To upgrade to the latest version, follow these steps:

Run git pull to fetch the latest changes from the repository.
Run make install to install the latest dependencies and update the project.

Acknowledgements

We would like to express our gratitude to the following contributors for their valuable contributions to the OpenChat project:

This project follows the all-contributors specification. Contributions of any kind are welcome!

License

OpenChat is licensed under the MIT License.

Conclusion

OpenChat aims to simplify the creation and management of chatbots powered by large language models. With its user-friendly interface and extensive features, OpenChat enables users to leverage the power of AI in their chatbot projects. Whether you are a developer or a non-technical user, OpenChat provides a streamlined experience for building and deploying chatbots. We are continuously working on enhancing OpenChat and incorporating new features based on user feedback and requirements. Feel free to join our Discord community and contribute to the project. Together, let's unlock the potential of large language models in chatbot development!

DEV Community: StackFoss

PCSX2: The Free and Open-Source PlayStation 2 Emulator

PCSX2: The Free and Open-Source PlayStation 2 Emulator

Project Details

System Requirements

Minimum System Requirements

Recommended System Requirements

Technical Notes

Embedchain: Building LLM-Powered Bots with Ease

Embedchain: Building LLM-Powered Bots with Ease

Getting Started

Installation

Usage

Supported Formats

YouTube Video

PDF File

Web Page

Text

Q&A Pair

More Formats Coming Soon

How Does It Work?

Tech Stack

Author

Spacedrive: A File Explorer from the Future

Spacedrive: A File Explorer from the Future

Features

Screenshots

Community and Development

License

Development Architecture

Monorepo Structure

Apps

Core

Packages

What is a VDFS?

Motivation

Roadmap

Skateshop13: An Open Source E-Commerce Skateshop Built with Next.js 13

Skateshop13: An Open Source E-Commerce Skateshop Built with Next.js 13

Tech Stack

Features

Installation

1. Clone the repository

2. Install dependencies

3. Create a .env file

4. Run the application

5. Push the database

6. Listen for Stripe events

Deployment

Cybernetically Enhanced Web Apps: Svelte

Cybernetically Enhanced Web Apps: Svelte

Introduction

What is Svelte?

Supporting Svelte

Roadmap

Contributing to Svelte

Development

Running Tests

svelte.dev

Troubleshooting

License

Generative Models by Stability AI

Generative Models by Stability AI

News

The codebase

General Philosophy

Changelog from the old ldm codebase

Installation:

1. Clone the repo

2. Setting up the virtualenv

Inference:

Invisible Watermark Detection

Controlled File System Interaction and Script Execution with Kaguya: A ChatGPT Plugin

Kaguya: Empowering Developers with Controlled File System Interaction

API Endpoints

Running the Project

Discover Kaguya in Action

Join the Kaguya Community on Discord

Linen: The Future of Community Chat

Linen: The Future of Community Chat

3. Create a `.env` file

Changelog from the old `ldm` codebase