hvTerrain is a terrain shader for URP I ended up making for my game. I got inspired by KUF2 terrain system (ps only, no clipmap stuff).

This is not a total replacement to Unity’s terrain shader. You should still use it for painting/viewing in-editor. Use hvTerrain once you finish your terrain and want more performance in-game. Baking is not destructive to original terrain.

I got a lot of help from around the web, forums and gamedev communities in general, so I decided to release it under MIT.

Also, it’s not production ready as I haven’t tested it fully yet. Give it a try and tell me how it goes.

• Pros
  • up to 256 textures
  • triplanar
  • per pixel normals
  • holes support
  • should be more perfomant than Unity’s Terrain
    • specially when using lots of textures
    • also, when NOT using triplanar
  • normal blending is correct (no multi-pass hacks)
• Cons
  • no ‘Draw Instanced’ support (Shader graph issue I guess)
  • needs baking
  • layers blend not so smooth
  • use of Texture2DArray
    • it might not work on some old devices
    • it requires same-sized textures
    • no compression
    • also needs manual handling per Graphics API (so I was told, haven’t tested on mobiles yet)

Because Unity’s Terrain frag shader is slow, specially when you need lots of textures, as it relies on control maps (or alpha maps / splat maps). It means that every 4 textures the terrain has to ‘re-render’.

For example, lets say we have 16 layers (albedo + normals):

• 4 * [n of passes] draw calls per terrain patch
• 4 samples for control maps
• 16 albedo samples + 16 normal samples
• what if we want triplanar ?
  • then we get 3 * 32 + 4 = 100 samples per pixel
  • and most of the sampled textures don’t even contribute

It actually is more of a baking system than a shader. It works by baking Unity’s Terrain data to textures.

I believe the shader ends up being a ‘constant-cost’ shader giving the sample count is mostly constant.

It should also have a higher overhead compared to Unity’s terrain shader though, since it is always going to sample 2 blendMaps + 8 albedos + 4 normals (if not using triplanar).

So for terrains with <= 4 textures, Unity’s terrain shader should be more efficient.

Here is the rundown:

• Bakes Terrain layers to Texture2DArrays
  • currently only bakes albedo_smooth + normalsTS_rg
  • also bakes layer’s normalScale and smoothness factors into textures
    • scaling normals to a texture might be bad a idea, need to test that more
  • bakes tile sizes to an array (_TexturesScale)
• Bakes SplatMaps to a texture called BlendMap0
  • blendMap0 channel layout = (id0, id1, weight, alpha)
    • alpha is a bitMask = [00000bxz] (applyBilinear isX isZ)
  • it supports blending up to 2 textures
  • axis is used for ‘triplanar’ (see KUF2 presentation)
  • ids need manual bilinear filtering on ps
  • normal mapping uses id0 only (for perf)
• Bakes Terrain surface data (normals + triplanar axis blend zones) to BlendMap1
  • blendMap1 channel layout = (x, y, z, axisBlend)
    • axisBlend is used for more efficient triplanar mapping
    • it’s a mask used to perform triplanar only at seam areas

In the PS:

• branch on blendMap0.a to decide to use bilinear or not
• branch on blendMap1.a to decide to use triplanar or not

So, if my math is right:

Best-case scenario:

• no bilinear
• no triplanar
• 2 blendMap (BlendMap0 + BlendMap1)
• 2 albedo (id0 + id1) (sometimes id0 == id1 so this could get cache optimized too)
• 1 normal (id0)
• Totals to 5 samples

Average-case scenario:

• bilinear
• no triplanar
• 5 blendMap (4 * BlendMap0 + BlendMap1)
• 4 * 2 * albedo (4 * (id0 + id1))
• 4 * normal (only id0)
• Totals to 17 samples

Worst-case scenario:

• bilinear
• triplanar
• triplanar = 17 * 3 (for each axis)
• Totals to 51 samples

Worst case is present at places where uv axis change (surface edges/ridges etc).

• Add hvTerrain component to a terrain gameobject
• Create a Unity Terrain material
• Create a hvTerrain material
• Assign materials to the hvTerrain component
• Create/Paint terrain as you normaly would
  • you can swtich materials by hvTerrain -> context menu -> switch material
  • you obviously should use Unity Terrain material while painting/sculpting for realtime preview
• Bake (hvTerrain -> contex menu -> bake)
• You can switch features on/off at the hvTerrain material
• Enabling/Disabling holes is a bit tricky
  • Make sure you enable ‘Alpha Clipping’ at shader graph + ‘Holes’ checkbox (also ‘Terrain Holes’ at the URPSettings asset)

This repository is a REST API with GO, Mux and SQLite.

Using GO, SQLite, CompileDaemon,etc preferably.

Using SQLite preferably.

Using Postman or RestEasy to feed the api.

$ git clone https://github.com/DanielArturoAlejoAlvarez/go-rest-api-orm.git
[NAME APP]

Follow the following steps and you’re good to go! Important:

...
package main

import (
	"fmt"
	"log"
	"net/http"

	"github.com/gorilla/mux"
)

func helloWorld(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "<h1>Hello World!</h1>")
}

func handleRequests() {
	router := mux.NewRouter().StrictSlash(true)
	router.HandleFunc("/users", getUsers).Methods("GET")
	router.HandleFunc("/users/{name}", getUser).Methods("GET")
	router.HandleFunc("/users/{name}/{email}", saveUser).Methods("POST")
	router.HandleFunc("/users/{name}/{email}", updateUser).Methods("PUT")
	router.HandleFunc("/users/{name}", deleteUser).Methods("DELETE")
	router.HandleFunc("https://github.com/", helloWorld).Methods("GET")
	log.Fatal(http.ListenAndServe(":5500", router))
}

func main() {
	fmt.Println("Welcome to REST API with ORM")

	InitialMigration()
	handleRequests()
}
...

...
package main

import (
	"encoding/json"
	"fmt"
	"net/http"

	"github.com/gorilla/mux"

	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/sqlite"
)

var db *gorm.DB
var err error

//User is esported
type User struct {
	gorm.Model
	Name  string
	Email string
}

//InitialMigration is exported
func InitialMigration() {
	db, err = gorm.Open("sqlite3", "test_db")
	if err != nil {
		fmt.Println(err.Error())
		panic("Failed connect DB!")
	}
	defer db.Close()

	db.AutoMigrate(&User{})
}

func getUsers(w http.ResponseWriter, r *http.Request) {
	db, err = gorm.Open("sqlite3", "test_db")
	if err != nil {
		fmt.Println(err.Error())
		panic("Failed connect DB!")
	}
	defer db.Close()

	var users []User

	db.Find(&users)
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(users)
}

func getUser(w http.ResponseWriter, r *http.Request) {
	db, err = gorm.Open("sqlite3", "test_db")
	if err != nil {
		fmt.Println(err.Error())
		panic("Failed connect DB!")
	}
	defer db.Close()

	vars := mux.Vars(r)
	name := vars["name"]

	var user User
	db.Where("name = ?", name).Find(&user)

	db.Find(&user)
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(user)
}

func saveUser(w http.ResponseWriter, r *http.Request) {
	db, err = gorm.Open("sqlite3", "test_db")
	if err != nil {
		fmt.Println(err.Error())
		panic("Failed connect DB!")
	}
	defer db.Close()

	vars := mux.Vars(r)
	name := vars["name"]
	email := vars["email"]

	db.Create(&User{Name: name, Email: email})

	fmt.Fprintf(w, "User saved successfully!")
}

func updateUser(w http.ResponseWriter, r *http.Request) {
	db, err = gorm.Open("sqlite3", "test_db")
	if err != nil {
		fmt.Println(err.Error())
		panic("Failed connect DB!")
	}
	defer db.Close()

	vars := mux.Vars(r)
	name := vars["name"]
	email := vars["email"]

	var user User
	db.Where("name = ?", name).Find(&user)

	user.Email = email
	db.Save(&user)

	fmt.Fprintf(w, "User updated successfully!")
}

func deleteUser(w http.ResponseWriter, r *http.Request) {
	db, err = gorm.Open("sqlite3", "test_db")
	if err != nil {
		fmt.Println(err.Error())
		panic("Failed connect DB")
	}
	defer db.Close()

	vars := mux.Vars(r)
	name := vars["name"]

	var user User
	db.Where("name = ?", name).Find(&user)
	db.Delete(&user)

	fmt.Fprintf(w, "User deleted successfully!")
}
...

Bug reports and pull requests are welcome on GitHub at https://github.com/DanielArturoAlejoAlvarez/go-rest-api-orm. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the Contributor Covenant code of conduct.

The gem is available as open source under the terms of the MIT License.

Adaptation of nativescript-fancyalert for react native. Compatible with expo 🤓

$ npm i react-native-expo-fancy-alerts

Or

$ yarn add react-native-expo-fancy-alerts

import React from 'react';
import { Text, TouchableOpacity, View } from 'react-native';
import { FancyAlert } from 'react-native-expo-fancy-alerts';

const App = () => {
  const [visible, setVisible] = React.useState(false);
  const toggleAlert = React.useCallback(() => {
    setVisible(!visible);
  }, [visible]);

  return (
    <View>
      <TouchableOpacity onPress={toggleAlert}>
        <Text>Tap me</Text>
      </TouchableOpacity>

      <FancyAlert
        visible={visible}
        icon={<View style={{
          flex: 1,
          display: 'flex',
          justifyContent: 'center',
          alignItems: 'center',
          backgroundColor: 'red',
          borderRadius: 50,
          width: '100%',
        }}><Text>🤓</Text></View>}
        style={{ backgroundColor: 'white' }}
      >
        <Text style={{ marginTop: -16, marginBottom: 32 }}>Hello there</Text>
      </FancyAlert>
    </View>
  )
}

export default App;

• NOTE – Alerts are not dismissed by tapping the blurry background

The following example illustrates how you can create a loading indicator for your entire app. If you’re using redux you may have a part of your store which says whether you’re loading something, you can get that flag and show one of the loading indicators offered by this lib.

import React from 'react';
import { useSelector } from 'react-redux';
import { LoadingIndicator } from 'react-native-expo-fancy-alerts';
import { selectIsLoading } from 'selectors';

const AppLoadingIndicator = () => {
  const isLoading = useSelector(selectIsLoading);
  return <LoadingIndicator visible={isLoading} />;
}

export default AppLoadingIndicator;

This next one is an error message that is also managed globally through redux.

import React from 'react';
import { Platform, Text, View, StyleSheet } from 'react-native';
import { useDispatch, useSelector } from 'react-redux';
import { FancyAlert } from 'react-native-expo-fancy-alerts';
import { Ionicons } from '@expo/vector-icons';
import { ErrorCreators } from 'creators';
import { selectError } from 'selectors';

const AppErrorModal = () => {
  const dispatch = useDispatch();
  const { hasError, error } = useSelector(selectError);

  const onRequestClose = React.useCallback(
    () => {
      dispatch(ErrorCreators.hideError());
    },
    [dispatch],
  );

  return <FancyAlert
    style={styles.alert}
    icon={
      <View style={[ styles.icon, { borderRadius: 32 } ]}>
        <Ionicons
          name={Platform.select({ ios: 'ios-close', android: 'md-close' })}
          size={36}
          color="#FFFFFF"
        />
      </View>
    }
    onRequestClose={onRequestClose}
    visible={hasError}
  >
    <View style={styles.content}>
      <Text style={styles.contentText}>{error ? error.message : ''}</Text>

      <TouchableOpacity style={styles.btn} onPress={onPress}>
        <Text style={styles.btnText}>OK</Text>
      </TouchableOpacity>
    </View>
  </FancyAlert>;
}

const styles = StyleSheet.create({
  alert: {
    backgroundColor: '#EEEEEE',
  },
  icon: {
    flex: 1,
    display: 'flex',
    justifyContent: 'center',
    alignItems: 'center',
    backgroundColor: '#C3272B',
    width: '100%',
  },
  content: {
    display: 'flex',
    flexDirection: 'column',
    justifyContent: 'center',
    alignItems: 'center',
    marginTop: -16,
    marginBottom: 16,
  },
  contentText: {
    textAlign: 'center',
  },
  btn: {
    borderRadius: 32,
    display: 'flex',
    flexDirection: 'row',
    justifyContent: 'center',
    alignItems: 'center',
    paddingHorizontal: 8,
    paddingVertical: 8,
    alignSelf: 'stretch',
    backgroundColor: '#4CB748',
    marginTop: 16,
    minWidth: '50%',
    paddingHorizontal: 16,
  },
  btnText: {
    color: '#FFFFFF',
  },
});

export default AppErrorModal;

• 0.0.1 – Initial implementation – has layout issues on Android that WILL be fixed
• 0.0.2 – Android issue fixed
• 0.0.3 – Added extra customization options
• 1.0.0 – Years later I decided to package everything and release 🎉🥳
• 2.0.0 – BREAKING CHANGES Updated FancyAlert to be more intuitive and more generic
• 2.0.1 – Updated docs to include some real-life examples
• 2.0.2 – Updated dependencies
• 2.1.0 – Added typescript typings

Table of Contents

• React Widgets
  • Technologies Used
  • Widgets
    • Clock
    • Weather
    • AutoComplete
    • Tabs

• React.js – Frontend JavaScript library
• Webpack – Module bundler
• @babel/core – JavaScript coverter for backwards compatibility
• Geolocation API – Request user’s current location and
• Open Weather API – Fetch free weather data for the user’s location

The Clock component displays the current date and time, updating every second.

• Date
  • Weekday (full length)
  • Month (full length)
  • Calendar date (two digit integer)
• Time
  • Seconds, minutes, and hours (in 12-hour format)
  • AM/PM indicator

The Weather component provides local weather data in an organized and digestible fashion. Weather data includes:

• Description
  • Short description of the current weather conditions along with a relevant icon
  • Current location being used for weather data
• Temperatures (all in fahrenheit)
  • feelsLike – what it currently ‘feels like’
  • actual – what the actual current temperature is
  • max and min – highest and lowest temperatures for the current date
• Wind
  • Directional arrow icon that is rotated based on the current direction of wind
  • Two letter abbreviations for the compass direction of the current wind
  • Speed of current wind (imperial miles/hr)
  • Gusts (imperial miles/hr), only if there are high wind gusts in the forecast

The AutoComplete component filters a list of names based on the user’s input. Matches are detected by comparing the user’s input to the list of names, each sliced to the length of input and checked for equality. When a user clicks on the recommended name, the field autocompletes the name and displays the company’s data below the search bar.

• Suggestions
  • Absolute positioned list of company names recommened based on user’s input
  • onClick event handler to complete the search and render the company data
• Dynamic Lists
  • The array of names suggested are provided as props, and therefore can easily be changed
  • Format of the company names accepted as props:

    [{ name: "Apple", revenue: "$274.5 B" }, ...]

The Tabs widget is an interactive container that dynamically displays content based on the label selected by the user.

• Dynamic Props
  • Tabs are passed as props formatted as an array objects, each with a title (string) and content (React Components or HTML Elements):

  [{title: "Weather", content: <Weather type='tab' />}, ...]

• Active Tabs
  • Selected tab index stored in component’s state
  • The actively selected tab is styled with a blue background, box-shadow, and bold text

• Javascript
• ReactJS
• NodeJS
• Python
• MERN
• HTML&CSS
• DevOps
• General Videos
• Interview Preparation
• Mobile app

• https://www.youtube.com/c/DevEd/videos
• https://www.youtube.com/@js_cafe
• https://www.youtube.com/@CodewithSloba/videos
• https://www.youtube.com/playlist?list=PL0Zuz27SZ-6N3bG4YZhkrCL3ZmDcLTuGd
• https://www.youtube.com/playlist?list=PL7pEw9n3GkoW5bYOhVAtmJlak3ZK7SaDf
• https://www.youtube.com/watch?v=3NHYl0Lo74A

• https://www.youtube.com/watch?v=ZAcASkz7pzE&list=PLynWqC6VC9KNS1QoKBHJdg3l-wSQ_NGC3
• https://www.freecodecamp.org/news/how-to-create-a-linkedin-clone/
• https://www.youtube.com/watch?v=3CXYWkXAdqc

• https://www.youtube.com/watch?v=a6905btNVoA
• https://www.youtube.com/watch?v=rltfdjcXjmk

• https://www.youtube.com/@BroCodez/videos
• https://www.youtube.com/@CodeWithHarry/videos

• https://www.youtube.com/watch?v=0cPCMIuDk2I
• https://www.youtube.com/@developerscorner/videos

• https://www.youtube.com/@OnlineTutorialsYT/videos
• https://www.youtube.com/@TheCoderCoder/videos

• https://www.youtube.com/@tamiltechwitharun/videos

• https://www.youtube.com/@codeSTACKr/videos
• https://www.youtube.com/@dailydotdev/videos
• https://www.youtube.com/@DecodedFrontend/videos
• https://dev.to/rahxuls/21-best-youtube-channels-for-designers-in-2023-1m47
• https://www.youtube.com/@LogicFirstTamil/playlists
• https://www.youtube.com/@Codevolution/videos

• https://www.youtube.com/@js_cafe/videos

• https://www.youtube.com/@RivaanRanawat/videos

• Feat: 새로운 알고리즘 문제 해결
• Modify: 풀었던 알고리즘 코드 수정
• Fix: 못 풀었던 문제 해결
• Comment: 주석 추가 or 수정 or 삭제
• Refactor: 성능에 관계 없는 코드 배치나 레포 구조 등 수정
• Docs: 리드미 업데이트

{Fast, Correct} – Choose two

Build and test software of any size, quickly and reliably.

• Speed up your builds and tests: Bazel rebuilds only what is necessary. With advanced local and distributed caching, optimized dependency analysis and parallel execution, you get fast and incremental builds.

• One tool, multiple languages: Build and test Java, C++, Android, iOS, Go, and a wide variety of other language platforms. Bazel runs on Windows, macOS, and Linux.

• Scalable: Bazel helps you scale your organization, codebase, and continuous integration solution. It handles codebases of any size, in multiple repositories or a huge monorepo.

• Extensible to your needs: Easily add support for new languages and platforms with Bazel’s familiar extension language. Share and re-use language rules written by the growing Bazel community.

• Install Bazel

• Get started with Bazel

• Follow our tutorials:

  • Build C++
  • Build Java
  • Android
  • iOS

• Bazel command line
• Rule reference
• Use the query command
• Extend Bazel
• Write tests
• Roadmap
• Who is using Bazel?

To report a security issue, please email security@bazel.build with a description of the issue, the steps you took to create the issue, affected versions, and, if known, mitigations for the issue. Our vulnerability management team will respond within 3 working days of your email. If the issue is confirmed as a vulnerability, we will open a Security Advisory. This project follows a 90 day disclosure timeline.

See CONTRIBUTING.md

Getting Started     Actions     Codesandbox

• ✨ Hook based: Specks has a simple API based on a React hook.
• 🔥 async actions: Actions can be synchronous and async.
• 🙅‍♀️ Providerless: Specks does not need a Context Provider.
• ◽️ Super minimalist: No need to set anything up or learn weird design patterns.
• 🔻 Tiny: Specks only has 82 lines of code.

Well, you might not always need Redux. Redux is very versatile, but it can get a bit too complicated, especially for small projects. Specks aims to be a tiny state management library for smaller projects. It is built for projects, where Redux is too much but React’s built in state management is not enough.

You must also install react for Specks to work.

# Using npm
npm install specks

# Using yarn
yarn add specks

import { createStore } from 'specks';

let { useStore } = createStore(({ get, set }) => {
  name: 'unknown',
  setName: (name) => {
    set({ name });
  }
});

let Component = () => {
  // Get the needed values from the store
  let name = useStore(s => s.name);
  let setName = useStore(s => s.setName);

  let onNameChange = (e) => {
    // Call the `setName` action
    setName(e.target.name);
  };

  return (
    <div>
      <p>Name: { name }</p>
      <input onChange={ onNameChange } value={ name }>
    </div>
  );
};

The initializer function is a function, which contains the initial state and all actions. It gets and object containing two functions (get and set) as its first parameter. The get function accepts no parameters and returns the whole state. The set function accepts a partial state object, which will be used to update the state (using Object.assign).

Actions are functions which can be used to update the state. In most cases you should use actions instead of updating the state directly. The can have parameters, which you can use to pass additional data, when calling the action.

let { /* ... */ } = createStore(({ get, set }) => {
  count: 0,
  addOne: () => {
    let currentCount = get().count;
    set({ count: currentCount + 1 });
  },
  add: (num) => {
    let currentCount = get().count;
    set({ count: currentCount + num });
  }
});

Actions can be async or synchronous, Specks does not care.

let { /* ... */ } = createStore(({ get, set }) => {
  // ...
  actionName: async () => {
    let data = await fetchDataFromServer();

    set({ data });
  }
});

If you use the useStore hook, the first Argument is a slicing function. It gets passed the whole state and returns any value. Specks will execute this function every time the state changes. If the function’s return value changes, the components using it will be rerendered. If the return value does not change, nothing will be rerendered.

The slices return value can be anything.

let Component = () => {
  // Getting a value from the store object
  let value = useStore(s => s.value);

  // Adding a 1 to a value from the store
  let count = useStore(s => s.count + 1);

  // Checking if something is set
  let valueExists = useStore(s => s.value !== undefined);

  // Use a store value in a string
  let greeting = useStore(s => `Hello ${ s.name }`);

  // ...
};

In some cases you might want to get or set the state outside of a React component. You can use the store object which is returned by createStore to do that. The store object has two functions: getState and setState. They behave similar the get and set in the initializer function.

let { store } = createStore(({ get, set }) => {
  name: 'unknown',
  setName: (name) => {
    set({ name });
  }
});

let name = store.getState();
store.setState({ name: 'John' });

The createStore function is exported from Specks and can be used to create a new store instance.

The initializer is a function which is used to set up the initial state and all actions. It has one parameter, which is an object containing a get and a set function used to manipulate the state.

let { /* ... */ } = createStore(({ get, set }) => {
  count: 0,
  add: (num) => {
    let currentCount = get().count;
    set({ count: currentCount + num });
  }
});

get returns the whole state.

set accepts a partial state object which is used to update state using Object.assign. Partial means that it only includes the values which should be changed, all others will remain untouched.

store can be used to manipulate the state outside of React. It has two values: getState and setState.

getState returns the whole state.

setState accepts a partial state object which is used to update state using Object.assign.

useStore is a React hook, which can be used to access the state and the actions in a React component.

slice is a function which is used to pick a specific value out of the state (eg. a value or an action). The component will only rerender if the slice’s return value changes. The slice function can return any value.

MIT © Tobias Herber

Project level lint status right in your favorite file explorer.

Tested on:

• Neovim 0.3.1+ – Linux
• Vim 8.0+ – Linux

• Vim or Neovim with “jobs” feature
• One of these file explorers:

1. NERDTree
2. Defx.nvim
3. Vimfiler.vim

Optional, but highly recommended for best performance:

• ripgrep or ag

Choose your favorite package manager. If you don’t have one, i recommend vim-packager

function! PackagerInit()
packadd vim-packager
call packager#add('kristijanhusak/vim-packager', {'type': 'opt'})
call packager#add('kristijanhusak/vim-project-lint')

"File explorers. Choose your favorite.
"NERDTree
call packager#add('scrooloose/nerdtree')

"Defx.nvim
call packager#add('Shougo/defx.nvim')

"Vimfiler
call packager#add('Shougo/unite.vim')
call packager#add('Shougo/vimfiler.vim')
endfunction
command! PackagerInstall call PackagerInit() | call packager#install()

"NERDTree
nnoremap <Leader>n :NERDTree<CR>

"vimfiler.vim
let g:vimfiler_explorer_columns = 'project_lint:type'
nnoremap <Leader>n :VimfilerExplorer

"defx.nvim
nnoremap <Leader>n :Defx -columns=project_lint:mark:filename:type<CR>

This is the default configuration:

"Styling
let g:project_lint#error_icon = '✖'
let g:project_lint#warning_icon = '⚠'
let g:project_lint#error_icon_color = 'guifg=#fb4934 ctermfg=167'
let g:project_lint#warning_icon_color = 'ctermfg=214 guifg=#fabd2f'

"Linter settings
"example:
" let g:project_lint#enabled_linters = {'javascript': ['eslint'], 'python': ['mypy']}
" If there's no setting provided for filetype, all available linters are used.
" If provided an empty array fora filetype, no linting is done for it.
let g:project_lint#enabled_linters = {}

"example:
"let g:project_lint#linter_args = {'mypy': '--ignore-missing-imports'}
let g:project_lint#linter_args = {}

"Folder settings
"Lint status is cached for each project in this folder.
let g:project_lint#cache_dir = '~/.cache/vim-project-lint'

" When this is left empty, all folders from $HOME and above are ignored and not linted:
" example of empty value: `['/home/kristijan', '/home', "https://github.com/"]`
" To allow linting these folders (not recommended), set this value to `v:false`
" Or use your own list of folders. When non-empty value is provided, above defaults are not added.
let g:project_lint#ignored_folders = []

"Other
" Echo linting progress in command line. Another way to get the progress info is to use statusline.
" example:
" set statusline+=project_lint#statusline()
let g:project_lint#echo_progress = v:true

" Prints all calls to linter commands and their responses. Mostly useful for development.
let g:project_lint#debug = v:false

MIT