Discover the Magic of Broccolini: Your New Favorite Super-Veggie!

Are you ready to meet your new favorite green vegetable?

Say hello to broccolini.

This delightful, nutritious, and versatile veggie is sure to light up your tastebuds and banish the boredom of eating the same ‘ole veggies at every meal.

Roasted broccolini is especially tasty with its companions of fresh garlic, blistered grape tomatoes, and a Sherry vinaigrette in this dish.

 

A Peek Into Broccolini’s History

Despite often being labeled baby broccoli, it is not baby broccoli.

Broccolini is a cross between Chinese broccoli and regular broccoli – yes, the kind that most people love to hate.

It was bred by a Japanese company in 1993 to create a vegetable that featured the tender stalks of Chinese broccoli along with the more familiar florets of traditional broccoli.

Broccolini has a sweet, mild flavor and a crisp texture, which is the best characteristics of both source plants.

And broccolini is not a GMO, or genetically modified organism.

It was developed through traditional plant breeding techniques that naturally combine the desired characteristics of each parent plant.

 

Nutrition Packed in Every Bite of Roasted Broccolini

Why should broccolini be on your shopping list and dinner plate?

This green gem is packed with a powerhouse of nutrients. Broccolini is rich in vitamins C and A, calcium, folate, iron, and is also a fantastic source of fiber.

It’s a champion for your bones, blood, and beyond with compounds that are believed to pack anti-inflammatory and cancer-fighting properties.

Low in calories but high in possibilities, broccolini is a superhero of the vegetable world, ready to keep you healthy while pleasing your palate.

 

Culinary Versatility

Broccolini is a versatile vegetable.

The stems, leaves, and florets are all edible, and they are tender enough to be enjoyed raw.

Use it in a stir-fry, steam it, or grill it. Toss it in a creamy pasta or serve it as a companion to your favorite protein.

 

Roasted Broccolini

Today’s recommendation is for a roasted broccolini salad with a sherry vinaigrette.

This vegetable is so tender it cooks to perfection in minutes.

Lay the broccolini on a sheet pan, add some sliced garlic and roast until the broccolini is tender and the florets just begin to char.

Blister some tomatoes in a dry cast iron and whip up a simple sherry vinaigrette.

Arrange the grape tomatoes on top of the broccolini and garlic when they come out of the oven.

Drizzle the sherry vinaigrette over the top.

It’s simplistic cooking and its best and it’s a winning combination you’re going to crave over and over.

Embrace the joy of eating something that looks as good as it tastes and feels as good as it nourishes.

Try it today.

Also give this broccoli recipe a spin.

Sautéed Broccoli

*As an Amazon Associate I earn from qualifying purchases.*

 

Print

Roasted Broccolini with Blistered Tomatoes and a Sherry Vinaigrette








Print Recipe





Pin Recipe

const share_pin_buttons = document.getElementsByClassName( 'share-pin button' );
if ( share_pin_buttons ) {
for ( let share_key = 0; share_key < share_pin_buttons.length; share_key++ ) {
share_pin_buttons[share_key].addEventListener( 'click', (e) => {
e.stopPropagation();
window.open(e.target.dataset.href,'targetWindow','toolbar=no,location=no,status=no,menubar=no,scrollbars=yes,resizable=yes,width=500,height=500');
return false;
} );
}
}

Broccolini has a sweet, mild flavor, and crisp texture that makes it a beautiful side dish to any protein or the vegetarian star of the show.

• 
  
• Author: Chef Sandra Lewis
  

Ingredients



Units
USM

Broccolini

• 
  
• 3–4 oz broccolini per person
  
• 1–2 garlic cloves per portion, thinly sliced
  
• 3–4 grape tomatoes per portion
  
• olive oil
  
• kosher salt
  
• red pepper flakes
  

Sherry Vinaigrette

• 
  
• 2 tablespoons Sherry vinegar
  
• 1 tablespoon Dijon mustard
  
• 1 tablespoon whole grain mustard
  
• 1/2 teaspoon sugar
  
• 1/4 cup olive oil
  
• kosher salt
  

Cook Mode

Prevent your screen from going dark







Instructions

Roasted Broccolini

1. 
   
2. Preheat oven to 425˚F.
   
3. Line a sheet tray with parchment paper (optional)
   
4. Lay the broccolini in a single layer on the sheet tray.
   
5. Scatter the thinly sliced garlic cloves over the top of the broccolini.
   
6. Drizzle with a bit of olive oi.
   
7. Season with kosher salt.
   
8. Roast the broccolini in the oven until tender and a bit charred, about 5-10 minutes.
   
9. While the broccolini roasts, blister the tomatoes in a dry cast iron pan until just small spots of char appear on the skin.
   
10. Remove the broccolini to a serving plate.
    
11. Garnish with the blistered tomatoes.
    
12. Drizzle the broccolini with the Sherry vinaigrette.
    
13. Garnish with the red pepper flakes.
    

Sherry Vinaigrette

1. 
   
2. Whisk together the Sherry vinegar, Dijon mustard, whole grain mustard, and sugar in a small bowl.
   
3. Whisk in the olive oil slowly, drizzling it in while you whisk.
   
4. Whisk until the olive oil is incorporated.
   
5. Taste and season with kosher salt as needed.
   

Notes

Optional garnishes:

• 
  
• freshly grated parmesan
  
• fresh oregano, lightly chopped
  

Did you make this recipe?

Tag @lifeatthetable on Instagram and hashtag it #whatsfordinner

window.trCommon={"minRating":6,"ajaxurl":"https:\/\/lifeatthetable.com\/wp-admin\/admin-ajax.php","ratingNonce":"","postId":175418961};
window.TastyRecipes = window.TastyRecipes || {};

window.TastyRecipes.smoothScroll = {
init() {
document.addEventListener( 'click', ( e ) => {
let anchor = e.target;
if ( anchor.tagName !== 'A' ) {
anchor = anchor.closest( 'a.tasty-recipes-scrollto' );
}

if ( ! anchor || ! anchor.classList.contains( 'tasty-recipes-scrollto' ) ) {
return;
}

const elementHref = anchor.getAttribute( 'href' );
if ( ! elementHref ) {
return;
}

e.preventDefault();
this.goToSelector( elementHref );
});
},
goToSelector( selector ) {
const element = document.querySelector( selector );
if ( ! element ) {
return;
}
element.scrollIntoView( { behavior: 'smooth' } );
}
};

document.addEventListener(
'DOMContentLoaded',
() => window.TastyRecipes.smoothScroll.init()
);

(function(){

var bothEquals = function( d1, d2, D ) {
var ret = 0;
if (d1 {
el.href = newURL;
});
};

document.addEventListener( 'DOMContentLoaded', () => {

if ( ! window.location.href.includes( '/print/' ) ) {
return;
}

const searchParams = new URLSearchParams( window.location.search );

const unit = searchParams.get( 'unit' );
const scale = searchParams.get( 'scale' );

if ( unit && ( 'metric' === unit || 'usc' === unit ) ) {
document.querySelector( '.tasty-recipes-convert-button[data-unit-type="' + unit + '"]' ).click();
}

if ( scale && Number(scale) > 0 ) {
document.querySelector( '.tasty-recipes-scale-button[data-amount="' + Number(scale) + '"]' ).click();
}
});
}());

(function(){
var buttonClass = 'tasty-recipes-convert-button',
buttonActiveClass = 'tasty-recipes-convert-button-active',
buttons = document.querySelectorAll('.tasty-recipes-convert-button');
if ( ! buttons ) {
return;
}
buttons.forEach(function(button){
button.addEventListener('click', function(event){
event.preventDefault();
var recipe = event.target.closest('.tasty-recipes');
if ( ! recipe ) {
return;
}
var otherButtons = recipe.querySelectorAll('.' + buttonClass);
otherButtons.forEach(function(bt){
bt.classList.remove(buttonActiveClass);
});
button.classList.add(buttonActiveClass);
var unitType = button.dataset.unitType;
var dataset = 'nf' + unitType.charAt(0).toUpperCase() + unitType.slice(1);
var convertables = recipe.querySelectorAll('span[data-nf-original]');
convertables.forEach(function(convertable){
if (typeof convertable.dataset.amountOriginalType === 'undefined'
&& 'usc' === convertable.dataset.nfOriginal) {
if (-1 !== convertable.innerText.indexOf('/')) {
convertable.dataset.amountOriginalType = 'frac';
}
if (-1 !== convertable.innerText.indexOf('.')) {
convertable.dataset.amountOriginalType = 'number';
}
Object.keys(window.tastyRecipesVulgarFractions).forEach(function(vulgar) {
if (-1 !== convertable.innerText.indexOf(vulgar)) {
convertable.dataset.amountOriginalType = 'vulgar';
}
});
}
convertable.innerText = convertable.dataset[dataset];
if (typeof convertable.dataset.unit !== 'undefined') {
convertable.dataset.unit = convertable.dataset[dataset + 'Unit'];
}
if (typeof convertable.dataset.amount !== 'undefined') {
convertable.dataset.amount = convertable.dataset[dataset];
if ('metric' === unitType) {
convertable.dataset.amountShouldRound = parseInt(convertable.dataset.amount) >= 10 ? 'integer' : 'number';
} else if (typeof convertable.dataset.amountOriginalType !== 'undefined') {
convertable.dataset.amountShouldRound = convertable.dataset.amountOriginalType;
} else {
convertable.dataset.amountShouldRound = false;
}
convertable.innerText = window.tastyRecipesFormatAmount(convertable.dataset[dataset], convertable);
}
if (convertable.classList.contains('nutrifox-unit')) {
if ('gram' === convertable.dataset[dataset]) {
convertable.innerText = 'grams';
}
}
});

document.querySelectorAll('.tasty-recipes-scale-button-active').forEach(function(scaleButton){
scaleButton.click();
});

window.tastyRecipesUpdatePrintLink();
});
});
}());

(function(){
document.querySelectorAll('[data-tr-ingredient-checkbox]').forEach(function(el) {
var input = el.querySelector('.tr-ingredient-checkbox-container input[type="checkbox"]');
if ( ! input ) {
return;
}
if (input.checked) {
el.dataset.trIngredientCheckbox = 'checked';
}
el.addEventListener('click', function(event) {
if ( 'A' === event.target.nodeName
|| 'INPUT' === event.target.nodeName
|| 'LABEL' === event.target.nodeName ) {
return;
}
input.click();
});
input.addEventListener('change', function() {
el.dataset.trIngredientCheckbox = input.checked ? 'checked' : '';
});
});
}());

window.TastyRecipes = window.TastyRecipes || {};
window.TastyRecipes.cookMode = {
wakeLockApi: false,
wakeLock: false,
cookModeSelector: '.tasty-recipes-cook-mode',
init() {
if ("wakeLock" in navigator && "request" in navigator.wakeLock) {
this.wakeLockApi = navigator.wakeLock;
}

const cookModes = document.querySelectorAll(this.cookModeSelector);

if (cookModes.length > 0) {
for (const cookMode of cookModes) {
if (this.wakeLockApi) {
cookMode.querySelector('input[type="checkbox"]').addEventListener("change", event => {
this.checkboxChange(event.target);
}, false);
} else {
cookMode.style.display = "none";
}
}
}
},
checkboxChange(checkbox) {
if (checkbox.checked) {
this.lock();
} else {
this.unlock();
}
},
setCheckboxesState(state) {
const checkboxes = document.querySelectorAll(this.cookModeSelector + ' input[type="checkbox"]');
for (const checkbox of checkboxes) {
checkbox.checked = state;
}
},
async lock() {
try {
this.wakeLock = await this.wakeLockApi.request("screen");
this.wakeLock.addEventListener("release", () => {
this.wakeLock = false;
this.setCheckboxesState(false);
});
this.setCheckboxesState(true);
} catch (error) {
this.setCheckboxesState(false);
}
},
unlock() {
if (this.wakeLock) {
this.wakeLock.release();
this.wakeLock = false;
}
this.setCheckboxesState(false);
}
};

(function(callback) {
if (document.readyState !== "loading") {
callback();
} else {
document.addEventListener("DOMContentLoaded", callback);
}
})(() => {
window.TastyRecipes.cookMode.init();
});

window.TastyRecipes = window.TastyRecipes || {};

window.TastyRecipes.staticTooltip = {
element: null,
tooltipElement: null,
deleting: false,
init( element ) {
if ( this.deleting ) {
return;
}
this.element = element;
this.buildElements();
},
destroy() {
if ( ! this.tooltipElement || this.deleting ) {
return;
}

this.deleting = true;
this.tooltipElement.classList.remove( 'opened' );

setTimeout( () => {
this.tooltipElement.remove();
this.deleting = false;
}, 500 );
},
buildElements() {
const tooltipElement = document.createElement( 'div' );
tooltipElement.classList.add( 'tasty-recipes-static-tooltip');
tooltipElement.setAttribute( 'id', 'tasty-recipes-tooltip' );

const currentTooltipElement = document.getElementById( 'tasty-recipes-tooltip' );
if ( currentTooltipElement ) {
document.body.replaceChild( tooltipElement, currentTooltipElement );
} else {
document.body.appendChild( tooltipElement );
}

this.tooltipElement = document.getElementById( 'tasty-recipes-tooltip' );
},
show() {
if ( ! this.tooltipElement ) {
return;
}

const tooltipTop = this.element.getBoundingClientRect().top
+ window.scrollY
- 10 // 10px offset.
- this.tooltipElement.getBoundingClientRect().height;
const tooltipLeft = this.element.getBoundingClientRect().left
- ( this.tooltipElement.getBoundingClientRect().width / 2 )
+ ( this.element.getBoundingClientRect().width / 2 ) - 1;
const posLeft = Math.max( 10, tooltipLeft );
this.maybeRemoveTail( posLeft !== tooltipLeft );

this.tooltipElement.setAttribute( 'style', 'top:' + tooltipTop + 'px;left:' + posLeft + 'px;' );
this.tooltipElement.classList.add( 'opened' );

},
maybeRemoveTail( removeTail ) {
if ( removeTail ) {
this.tooltipElement.classList.add( 'tr-hide-tail' );
} else {
this.tooltipElement.classList.remove( 'tr-hide-tail' );
}
},
changeMessage( message ) {
if ( ! this.tooltipElement ) {
return;
}
this.tooltipElement.innerHTML = message;
}
};

window.TastyRecipes.ajax = {
sendPostRequest( url, data, success, failure ) {
const xhr = new XMLHttpRequest();
xhr.open( 'POST', url, true );
xhr.send( this.preparePostData( data ) );

xhr.onreadystatechange = () => {
if ( 4 !== xhr.readyState ) {
return;
}
if ( xhr.status === 200 ) {
success( JSON.parse( xhr.responseText ) );
return;
}

failure( xhr );
};

xhr.onerror = () => {
failure( xhr );
};
},
preparePostData( data ) {
const formData = new FormData();

for ( const key in data ) {
formData.append( key, data[key] );
}
return formData;
},
};

window.TastyRecipes.ratings = {
defaultRating: 0,
currentRatingPercentage: 100,
savingRating: false,
init( minRating ) {
this.minRating = minRating;

this.formWatchRating();
this.closeTooltipWhenClickOutside();
this.addBodyClassBasedOnSelectedRating();
this.backwardCompFormRatingPosition();
},
formWatchRating() {
const ratings = document.querySelectorAll('.tasty-recipes-no-ratings-buttons [data-rating]');
if ( ratings.length {
event.preventDefault();
this.defaultRating = event.target.closest( '.checked' ).dataset.rating;
this.setCheckedStar( event.target );
this.maybeSendRating( this.defaultRating, event.target );
this.setRatingInForm( this.defaultRating );
} );
}
},
closeTooltipWhenClickOutside() {
window.addEventListener( 'click', e => {
// Bailout (don't remove the tooltip) when the clicked element is a rating star, or it's the tooltip itself.
if ( e.target.closest( '.tasty-recipes-rating' ) || e.target.classList.contains( 'tasty-recipes-static-tooltip' ) ) {
return;
}

window.TastyRecipes.staticTooltip.destroy();
} );
},
setRatingInForm( rating ) {
const ratingInput = document.querySelector( '#respond .tasty-recipes-rating[value="' + rating + '"]' );
if ( ! ratingInput ) {
return;
}
ratingInput.click();
},
addBodyClassBasedOnSelectedRating() {
const ratingInputs = document.querySelectorAll( 'input.tasty-recipes-rating' );
if ( ! ratingInputs ) {
return;
}
for ( const ratingInput of ratingInputs ) {
ratingInput.addEventListener( 'click', currentEvent => {
const selectedRating = currentEvent.target.getAttribute( 'value' );
this.handleBodyClassByRating( selectedRating );
this.toggleCommentTextareaRequired( selectedRating );
} );
}
},
handleBodyClassByRating( rating ) {
if ( rating < this.minRating ) {
document.body.classList.remove( 'tasty-recipes-selected-minimum-rating' );
return;
}
document.body.classList.add( 'tasty-recipes-selected-minimum-rating' );
},
toggleCommentTextareaRequired( rating ) {
const commentTextarea = document.getElementById( 'comment' );
if ( ! commentTextarea ) {
return;
}

if ( rating < this.minRating ) {
commentTextarea.setAttribute( 'required', '' );
return;
}

commentTextarea.removeAttribute( 'required' );
},
maybeSendRating( rating, element ) {
if ( this.savingRating === rating ) {
return;
}

this.savingRating = rating;
window.TastyRecipes.staticTooltip.init( element );

const recipeCardElement = element.closest( '.tasty-recipes' );
if ( ! recipeCardElement ) {
window.TastyRecipes.staticTooltip.destroy();
return;
}

window.TastyRecipes.ajax.sendPostRequest(
window.trCommon.ajaxurl,
{
action: 'tasty_recipes_save_rating',
rating,
nonce: window.trCommon.ratingNonce,
post_id: window.trCommon.postId,
recipe_id: recipeCardElement.dataset.trId,
},
( response ) => {
window.TastyRecipes.staticTooltip.changeMessage( response.data.message );
window.TastyRecipes.staticTooltip.show();
this.updateAverageText( response.data, recipeCardElement );
this.maybeFillCommentForm( response.data );

// Hide the tooltip after 5 seconds.
setTimeout( () => {
this.maybeResetTooltip( recipeCardElement, response.data, rating );
}, 5000 );
},
() => {
this.resetTooltip( recipeCardElement );
}
);
},
updateAverageText( data, recipeCardElement ) {
if ( ! data.average ) {
return;
}
this.setRatingPercent( data );

if ( ! data.count ) {
return;
}

const quickLink = document.querySelector( '.tasty-recipes-rating-link' );
if ( quickLink ) {
this.setTextInContainer( quickLink, data );
this.setPartialStar( quickLink );
}

const cardStars = recipeCardElement.querySelector( '.tasty-recipes-ratings-buttons' );
cardStars.dataset.trDefaultRating = data.average;
this.setTextInContainer( recipeCardElement.querySelector( '.tasty-recipes-rating' ), data );
},
setTextInContainer( container, data ) {
if ( ! container ) {
return;
}

if ( data.label ) {
const ratingLabelElement = container.querySelector( '.rating-label' );
if ( ratingLabelElement ) {
ratingLabelElement.innerHTML = data.label;
}
return;
}

const averageElement = container.querySelector( '.average' );
if ( averageElement ) {
averageElement.textContent = data.average;
}

const countElement = container.querySelector( '.count' );
if ( countElement ) {
countElement.textContent = data.count;
}
},
setPartialStar( container ) {
const highestStar = container.querySelector( '[data-rating="' + Math.ceil( this.defaultRating ) + '"]' );
if ( highestStar ) {
highestStar.dataset.trClip = this.currentRatingPercentage;
}
},
setRatingPercent( data ) {
this.defaultRating = data.average.toFixed( 1 );
const parts = data.average.toFixed( 2 ).toString().split( '.' );
this.currentRatingPercentage = parts[1] ? parts[1] : 100;
if ( this.currentRatingPercentage === '00' ) {
this.currentRatingPercentage = 100;
}
},
setCheckedStar( target ) {
const cardRatingContainer = target.closest( '.tasty-recipes-ratings-buttons' );
const selectedRatingElement = cardRatingContainer.querySelector( '[data-tr-checked]' );
if ( selectedRatingElement ) {
delete selectedRatingElement.dataset.trChecked;
}

const thisStar = target.closest( '.tasty-recipes-rating' );
thisStar.dataset.trChecked = 1;
thisStar.querySelector( '[data-tr-clip]' ).dataset.trClip = 100;
},
maybeFillCommentForm( data ) {
if ( ! data.comment || ! data.comment.content ) {
return;
}

const commentForm = document.querySelector( '#commentform' );
if ( ! commentForm ) {
return;
}

const commentBox = commentForm.querySelector( '[name=comment]' );
if ( ! commentBox || commentBox.value ) {
return;
}

// Add comment details for editing.
commentBox.innerHTML = data.comment.content;
if ( data.comment.name ) {
commentForm.querySelector( '[name=author]' ).value = data.comment.name;
commentForm.querySelector( '[name=email]' ).value = data.comment.email;
}
},
maybeResetTooltip( recipeCardElement, data, rating ) {
if ( this.savingRating === rating ) {
this.resetTooltip( recipeCardElement, data );
}
},
resetTooltip( recipeCardElement, data ) {
window.TastyRecipes.staticTooltip.destroy();
this.savingRating = false;

// Reset the default rating.
const cardRatingContainer = recipeCardElement.querySelector( '.tasty-recipes-ratings-buttons' );
if ( cardRatingContainer ) {
this.defaultRating = ( data && data.average ) ? data.average.toFixed(1) : cardRatingContainer.dataset.trDefaultRating;
cardRatingContainer.dataset.trDefaultRating = this.defaultRating;

this.resetSelectedStar( cardRatingContainer, data );
}
},
resetSelectedStar( cardRatingContainer ) {
const selectedRatingElement = cardRatingContainer.querySelector( '[data-rating="' + Math.ceil( this.defaultRating ) + '"]' );
if ( selectedRatingElement ) {
selectedRatingElement.querySelector( '[data-tr-clip]' ).dataset.trClip = this.currentRatingPercentage;
selectedRatingElement.parentNode.dataset.trChecked = 1;
}

const previousSelectedElement= cardRatingContainer.querySelector( '[data-tr-checked]' );
if ( previousSelectedElement ) {
const currentSelectedRating = previousSelectedElement.querySelector('[data-rating]');
if ( currentSelectedRating !== selectedRatingElement ) {
delete previousSelectedElement.dataset.trChecked;
}
}
},
backwardCompFormRatingPosition() {
const ratingsButtons = document.querySelector( '#respond .tasty-recipes-ratings-buttons, #tasty-recipes-comment-rating .tasty-recipes-ratings-buttons' );
if ( ! ratingsButtons ) {
return;
}
const ratingsButtonsStyles = window.getComputedStyle(ratingsButtons);
if ( ! ratingsButtonsStyles.display.includes( 'flex' ) ) {
ratingsButtons.style.direction = 'rtl';
}

if ( typeof tastyRecipesRating !== 'undefined' ) {
// Select the rating that was previously selected in admin.
ratingsButtons.querySelector( '.tasty-recipes-rating[value="' + tastyRecipesRating + '"]' ).checked = true;
}

const ratingSpans = ratingsButtons.querySelectorAll( '.tasty-recipes-rating' );
for (const ratingSpan of ratingSpans) {
ratingSpan.addEventListener( 'click', event => {
if ( ratingSpan === event.target ) {
return;
}
ratingSpan.previousElementSibling.click();
} );
}
}
};

(function(callback) {
if (document.readyState !== "loading") {
callback();
} else {
window.addEventListener( 'load', callback );
}
})(() => {
window.TastyRecipes.ratings.init( window.trCommon ? window.trCommon.minRating : 4 );
});

The post Roasted Broccolini appeared first on Life At The Table.